local 召唤兽处理类 = class()
local 资质范围 = {
	"攻击资质",
	"防御资质",
	"体力资质",
	"法力资质",
	"速度资质",
	"躲闪资质"
}
local 属性范围 = {
	"体质",
	"魔力",
	"力量",
	"耐力",
	"敏捷"
}
local bbs = 取宝宝
local rand = 取随机小数
local cfs = 删除重复
local ceil = math.ceil
local insert = table.insert
local floor = math.floor
local 五行_ = {
	"金",
	"木",
	"水",
	"火",
	"土"
}
可进阶宝宝列表 = {
	进阶执音 = 1,
	进阶判官 = 1,
	进阶小毛头 = 1,
	["进阶巨石守卫(昼)"] = 1,
	进阶千年蛇魅 = 1,
	进阶小魔头 = 1,
	进阶超级离火兽 = 1,
	进阶幽灵虎 = 1,
	进阶净瓶女娲 = 1,
	进阶连弩车 = 1,
	进阶机关人 = 1,
	进阶葫芦宝贝 = 1,
	进阶兔乖乖 = 1,
	进阶白子画 = 1,
	["进阶五行山神(金)"] = 1,
	进阶月魅 = 1,
	进阶灵鹤 = 1,
	进阶四翼上仙 = 1,
	进阶光辉女神 = 1,
	进阶无名上仙 = 1,
	进阶夜游神 = 1,
	进阶蛟龙 = 1,
	进阶战神罗成 = 1,
	进阶碧水夜叉 = 1,
	进阶谛听 = 1,
	进阶小仙女 = 1,
	["进阶五行山神(土)"] = 1,
	进阶芙蓉仙子 = 1,
	进阶赵云 = 1,
	进阶金衣仙 = 1,
	进阶贪狼 = 1,
	进阶部落勇士 = 1,
	进阶关羽 = 1,
	进阶神武雨师 = 1,
	进阶小战神 = 1,
	进阶巨灵神 = 1,
	进阶哮天犬 = 1,
	进阶玄珠灵仙 = 1,
	进阶增长巡守 = 1,
	进阶持国巡守 = 1,
	["进阶司辰侍者(过去)"] = 1,
	进阶星灵仙子 = 1,
	进阶长乐灵仙 = 1,
	进阶花铃 = 1,
	进阶红萼仙子 = 1,
	进阶齐天小圣 = 1,
	进阶多闻巡守 = 1,
	进阶超级神猴 = 1,
	进阶女狐妖 = 1,
	进阶司雨 = 1,
	进阶赤炎战神 = 1,
	进阶灵灯侍者 = 1,
	进阶超级人参娃娃 = 1,
	进阶超级麒麟 = 1,
	进阶小魔女 = 1,
	进阶罗汉 = 1,
	进阶机关鸟 = 1,
	进阶野猪精 = 1,
	进阶犀牛将军兽形 = 1,
	进阶蝎子精 = 1,
	进阶白無常 = 1,
	进阶狐不归 = 1,
	进阶雨师 = 1,
	进阶灵符女娲 = 1,
	进阶小丫丫 = 1,
	进阶喷火变脸 = 1,
	进阶超级猪小戒 = 1,
	进阶超级泡泡 = 1,
	进阶猫灵人形 = 1,
	进阶月影兔 = 1,
	进阶法僧 = 1,
	进阶猫灵兽形 = 1,
	进阶狂豹人形 = 1,
	进阶超级土地公公 = 1,
	进阶金身罗汉 = 1,
	进阶黑山老妖 = 1,
	进阶红孩儿 = 1,
	进阶超级大象 = 1,
	进阶手铃变脸 = 1,
	进阶白骨精 = 1,
	进阶老鹰精 = 1,
	进阶鲛人鱼 = 1,
	进阶白娘子 = 1,
	进阶白脸京剧 = 1,
	进阶武罗仙子 = 1,
	进阶超级神鸡 = 1,
	进阶雾中仙 = 1,
	进阶黑白狂豹人形 = 1,
	进阶巨斧猛男 = 1,
	进阶天师 = 1,
	进阶紫霞 = 1,
	进阶小圣斗士 = 1,
	进阶壬寅神虎 = 1,
	["进阶无常鬼差(白)"] = 1,
	进阶蚩尤武魂 = 1,
	进阶赵敏 = 1,
	进阶呆枭 = 1,
	进阶龙虾骑士 = 1,
	进阶金麟鹿 = 1,
	进阶葫仙 = 1,
	进阶黑翼弓使 = 1,
	进阶超级大鹏 = 1,
	进阶狂狮 = 1,
	进阶杀阡陌 = 1,
	进阶蝶妖 = 1,
	进阶古代瑞兽 = 1,
	进阶龙剑士 = 1,
	进阶小佐助 = 1,
	进阶白龙骑士 = 1,
	进阶天帝 = 1,
	进阶锦毛貂精 = 1,
	进阶镇元 = 1,
	进阶超级神猪 = 1,
	进阶鬼君 = 1,
	进阶涂山雪 = 1,
	进阶天后 = 1,
	进阶水龙 = 1,
	进阶龙鲤 = 1,
	进阶太极老君 = 1,
	进阶阎王爷 = 1,
	进阶魔化毗舍童子 = 1,
	进阶紫霞仙子 = 1,
	进阶蓝凤凰 = 1,
	进阶超级神狗 = 1,
	进阶Q版魔化毗舍童子 = 1,
	进阶剑圣 = 1,
	进阶小红孩儿 = 1,
	进阶托塔娃 = 1,
	进阶超级大熊猫 = 1,
	进阶夜莺 = 1,
	进阶李蓉蓉 = 1,
	进阶怜星 = 1,
	进阶洛神 = 1,
	进阶自在心猿 = 1,
	进阶阿宝 = 1,
	["进阶巨石守卫(夜)"] = 1,
	进阶青霞仙子 = 1,
	进阶超级孔雀 = 1,
	进阶火龙骑士 = 1,
	进阶金凤凰 = 1,
	进阶通臂猿猴 = 1,
	进阶凤九 = 1,
	进阶镜妖 = 1,
	进阶小狐狸 = 1,
	进阶宇智波鼬 = 1,
	进阶剑灵双子 = 1,
	进阶混沌兽 = 1,
	进阶蓝人龙 = 1,
	进阶暗黑毗舍童子 = 1,
	进阶月影仙 = 1,
	进阶超级白泽 = 1,
	进阶广目巡守 = 1,
	进阶真陀护法 = 1,
	进阶李洛克 = 1,
	进阶小南 = 1,
	进阶神僧 = 1,
	进阶蚩尤 = 1,
	进阶鸟妖仙 = 1,
	进阶神兽时光叽 = 1,
	进阶斧魂 = 1,
	进阶鲲鹏 = 1,
	进阶天将 = 1,
	进阶女飞贼 = 1,
	进阶邀月 = 1,
	进阶蚌精 = 1,
	进阶鬼妃 = 1,
	进阶月灵 = 1,
	进阶琴鹤 = 1,
	进阶晶怪 = 1,
	进阶狮仙 = 1,
	进阶吉祥 = 1,
	进阶机关兽 = 1,
	进阶巴蛇 = 1,
	进阶女仙 = 1,
	进阶白衣剑客 = 1,
	进阶尉迟恭 = 1,
	进阶神兽雪精灵 = 1,
	进阶蝴蝶仙子 = 1,
	进阶大象精 = 1,
	进阶超级神羊 = 1,
	进阶超级神龙 = 1,
	["进阶八尾·牛鬼"] = 1,
	进阶四臂魔神 = 1,
	进阶葫芦小金刚 = 1,
	进阶修罗傀儡鬼 = 1,
	进阶吸血鬼 = 1,
	进阶嘲风 = 1,
	进阶黑灵猫 = 1,
	进阶超级神兔 = 1,
	进阶吕布 = 1,
	进阶二大王 = 1,
	进阶超级神蛇 = 1,
	进阶小绅士 = 1,
	进阶幼狮 = 1,
	进阶龙仙 = 1,
	进阶超级青鸾 = 1,
	进阶超级赤焰兽 = 1,
	进阶虬龙 = 1,
	进阶小神女 = 1,
	进阶黑猫警长 = 1,
	进阶龙女 = 1,
	进阶沙暴 = 1,
	进阶春野樱 = 1,
	进阶噬天虎 = 1,
	进阶飞天 = 1,
	进阶绿巨人 = 1,
	进阶红衣仙女 = 1,
	进阶钢铁侠 = 1,
	进阶雷神托尔 = 1,
	进阶月皇 = 1,
	进阶灭霸 = 1,
	进阶癸卯神兔 = 1,
	进阶小神灵 = 1,
	进阶怒鳞 = 1,
	进阶新孙悟空 = 1,
	["进阶五行山神(木)"] = 1,
	进阶酷炫老逼登 = 1,
	进阶紫焰妖姬 = 1,
	进阶白熊 = 1,
	进阶白素贞 = 1,
	进阶春岚蔷薇 = 1,
	进阶卧龙 = 1,
	进阶超级神牛 = 1,
	进阶枪魂 = 1,
	进阶小青 = 1,
	进阶踏云兽 = 1,
	进阶妖星 = 1,
	进阶暗黑谛听 = 1,
	进阶凤凰 = 1,
	进阶杨二郎 = 1,
	进阶泪妖 = 1,
	进阶大力金刚 = 1,
	进阶剑仙 = 1,
	进阶貂裘红衣 = 1,
	["进阶司辰侍者(未来)"] = 1,
	进阶广目天王 = 1,
	进阶黑悟空 = 1,
	进阶画仙 = 1,
	进阶女捕头 = 1,
	进阶司风 = 1,
	进阶三尾妖狐 = 1,
	进阶黑脸判官 = 1,
	进阶有苏鸩 = 1,
	进阶男狐妖 = 1,
	进阶婚纱女 = 1,
	进阶小蓝娥 = 1,
	进阶般若天女 = 1,
	进阶金铙僧 = 1,
	进阶镜子变脸 = 1,
	进阶甲辰神龙 = 1,
	进阶涂山瞳 = 1,
	进阶美猴王 = 1,
	进阶超级灵鹿 = 1,
	进阶巡游天神 = 1,
	进阶夜罗刹 = 1,
	进阶超级飞廉 = 1,
	进阶律法女娲 = 1,
	进阶萼华仙子 = 1,
	进阶蜃气妖 = 1,
	进阶三叉变脸 = 1,
	进阶神兽小龙人 = 1,
	进阶玄武 = 1,
	进阶拽王 = 1,
	进阶红衣战锤使 = 1,
	进阶长鞭变脸 = 1,
	进阶金锤变脸 = 1,
	进阶超级神鼠 = 1,
	进阶仙兽翼龙 = 1,
	进阶太极神君 = 1,
	进阶画魂 = 1,
	进阶蝠女 = 1,
	进阶独角鬼王 = 1,
	进阶剑姬 = 1,
	进阶小欣 = 1,
	进阶熊猫大侠 = 1,
	进阶曼珠沙华 = 1,
	进阶小蓝 = 1,
	进阶妙华天女 = 1,
	进阶三尾火狐 = 1,
	进阶黑脸京剧 = 1,
	进阶小彩蝶 = 1,
	进阶花无缺 = 1,
	进阶觉醒涂山雪 = 1,
	进阶光明战神 = 1,
	进阶小浪鼓 = 1,
	进阶暗黑龙 = 1,
	进阶魔化吕布 = 1,
	进阶龙龟 = 1,
	进阶小兔兔 = 1,
	进阶小熊熊 = 1,
	进阶小DJ = 1,
	进阶小卷发 = 1,
	进阶小羊角 = 1,
	进阶六道带土 = 1,
	进阶炼丹童子 = 1,
	进阶宇智波佐助 = 1,
	进阶大筒木辉夜 = 1,
	进阶鼬 = 1,
	进阶佐助 = 1,
	进阶龙剑女 = 1,
	进阶惊奇队长 = 1,
	进阶旗木卡卡西 = 1,
	进阶路飞 = 1,
	进阶鸣人 = 1,
	进阶小鸣人 = 1,
	进阶月仙 = 1,
	["进阶一尾·守鹤"] = 1,
	进阶琴瑟仙女 = 1,
	进阶蓝衣剑魂 = 1,
	["进阶二尾·又旅"] = 1,
	进阶巨灵狼 = 1,
	进阶砍刀猴 = 1,
	["进阶四尾·孙悟空"] = 1,
	进阶孙行者 = 1,
	["进阶五尾·穆王"] = 1,
	进阶神武风伯 = 1,
	["进阶六尾·犀犬"] = 1,
	["进阶七尾·重明"] = 1,
	进阶小精灵 = 1,
	进阶金长毛猪 = 1,
	进阶幻姬 = 1,
	进阶日游神 = 1,
	["进阶无常鬼差(黑)"] = 1,
	["进阶九尾·九喇嘛"] = 1,
	进阶如意仙子 = 1,
	进阶神兽百灵羊 = 1,
	进阶鹿君 = 1,
	进阶阿朱 = 1,
	进阶骏天马 = 1,
	进阶暗雷豹 = 1,
	进阶氪金大佬 = 1,
	进阶彩蝶依依 = 1,
	进阶癸卯神兔_睡梦 = 1,
	["进阶三尾·矶抚"] = 1,
	进阶超级神马 = 1,
	进阶幽萤娃娃 = 1,
	进阶超级筋斗云 = 1,
	进阶红娘子 = 1,
	进阶雷龙 = 1,
	进阶酷炫佬 = 1,
	进阶魂女猫 = 1,
	进阶虎王 = 1,
	进阶战将 = 1,
	进阶超级灵狐 = 1,
	进阶猫女 = 1,
	进阶天兵 = 1,
	进阶云游火 = 1,
	进阶鼠先锋 = 1,
	进阶超级神虎 = 1,
	进阶鲛人 = 1,
	进阶小肥羊 = 1,
	进阶青衣 = 1,
	进阶雷鸟人 = 1,
	进阶鬼将 = 1,
	进阶百足将军 = 1,
	进阶龙王 = 1,
	进阶超级金猴 = 1,
	进阶神兽孙小圣 = 1,
	进阶我爱罗 = 1,
	进阶风伯 = 1,
	进阶超级小白龙 = 1,
	进阶绿衣女神 = 1,
	进阶龙羽 = 1,
	进阶小雪人 = 1,
	进阶巨力神猿 = 1,
	进阶太极捶童子 = 1,
	进阶藤蔓妖花 = 1,
	进阶狂豹兽形 = 1,
	进阶福禄仙 = 1,
	进阶鬼魅 = 1,
	进阶超级三眼娃 = 1,
	进阶带土 = 1,
	进阶炎魔神 = 1,
	进阶火熔石 = 1,
	进阶超级红孩儿 = 1,
	进阶齐天大圣 = 1,
	进阶关羽变脸 = 1,
	进阶辛丑神牛 = 1,
	进阶大蛇丸 = 1,
	进阶新猪八戒 = 1,
	进阶地狱战神 = 1,
	进阶龙魂仙女 = 1,
	["进阶五行山神(火)"] = 1,
	进阶长眉灵猴 = 1,
	进阶幽灵 = 1,
	进阶萌狗 = 1,
	进阶莲女 = 1,
	进阶剑魂 = 1,
	进阶死亡骑士 = 1,
	进阶琴仙 = 1,
	进阶智慧女神 = 1,
	进阶超级有熊 = 1,
	进阶太极真君 = 1,
	进阶团团 = 1,
	进阶宇智波带土 = 1,
	进阶修罗傀儡妖 = 1,
	进阶金翼 = 1,
	进阶火女 = 1,
	进阶逍遥神牛 = 1,
	进阶五彩神女 = 1,
	进阶神射手 = 1,
	进阶天兵统领 = 1,
	进阶司雪 = 1,
	进阶超级玉兔 = 1,
	进阶超级海豚 = 1,
	进阶犀牛将军人形 = 1,
	进阶金钱龟 = 1,
	进阶老夫子 = 1,
	进阶超级六耳猕猴 = 1,
	进阶阴阳伞 = 1,
	进阶狗头人 = 1,
	进阶部落酋长 = 1,
	进阶毗舍童子 = 1,
	进阶干柿鬼鲛 = 1,
	进阶佛子 = 1,
	进阶貂蝉 = 1,
	进阶月宫仙子 = 1,
	["进阶五行山神(水)"] = 1,
	进阶风火轮器灵 = 1,
	进阶佩恩 = 1,
	进阶蓝仙女 = 1,
	进阶龙须豹 = 1,
	进阶超级神柚 = 1,
	进阶六道斑 = 1,
	进阶嵩鼠 = 1
}
特殊宠物合成概率 = 25
特殊宠物合成公式 = {
	熔岩龟 = {
		云龟 = "火云龟",
		冰龟 = "冰火龟"
	},
	冰龟 = {
		岩龟 = "岩冰龟",
		熔岩龟 = "冰火龟"
	},
	云龟 = {
		毒花龟 = "毒云龟",
		熔岩龟 = "火云龟"
	},
	毒花龟 = {
		云龟 = "毒云龟"
	},
	岩龟 = {
		冰龟 = "岩冰龟"
	},
	草叶虫 = {
		食魂虫 = "草叶魂虫"
	},
	食魂虫 = {
		草叶虫 = "草叶魂虫"
	},
	沙虫 = {
		熔火虫 = "火沙虫"
	},
	熔火虫 = {
		金乌虫 = "金乌火虫",
		沙虫 = "火沙虫"
	},
	金乌虫 = {
		熔火虫 = "金乌火虫",
		月光虫 = "金乌月光虫"
	},
	月光虫 = {
		金乌虫 = "金乌月光虫"
	},
	熔火蛙 = {
		望月挖 = "火月蛙"
	},
	望月挖 = {
		熔火蛙 = "火月蛙"
	},
	龟蛙 = {
		积水蛙 = "积水鬼蛙"
	},
	积水蛙 = {
		龟蛙 = "积水鬼蛙"
	},
	望月蛙 = {
		雪蛙 = "月光雪蛙"
	},
	雪蛙 = {
		望月蛙 = "月光雪蛙"
	},
	沙狸 = {
		强盗狸 = "强盗沙狸"
	},
	强盗狸 = {
		沙狸 = "强盗沙狸",
		鬼狸 = "强盗鬼狸"
	},
	海狸 = {
		雪狸 = "胖海狸"
	},
	雪狸 = {
		海狸 = "胖海狸"
	},
	鬼狸 = {
		强盗狸 = "强盗鬼狸",
		纵火狸 = "鬼火狸"
	},
	纵火狸 = {
		鬼狸 = "鬼火狸"
	}
}

require("Script/数据中心/梦战召唤兽模型")

function 召唤兽处理类:初始化(id)
end

function 召唤兽处理类:数据处理(连接id, 序号, id, 内容)
	if 玩家数据[id].摊位数据 ~= nil and 序号 ~= 5001 then
		常规提示(id, "#Y/摆摊状态下禁止此种行为")

		return
	end

	if 序号 == 5001 then
		发送数据(连接id, 17, self.数据)
	elseif 序号 == 5002 then
		self:参战处理(连接id, 序号, id, 内容.序列)
	elseif 序号 == 5003 then
		self:改名处理(连接id, 序号, id, 内容.序列, 内容.名称)
	elseif 序号 == 5004 then
		self:加点处理(连接id, 序号, id, 内容)
	elseif 序号 == 5004.1 then
		self:保存加点方案(连接id, 序号, id, 内容)
	elseif 序号 == 5004.2 then
		local bh = 内容.序列

		if self.数据[bh] ~= nil then
			self.数据[bh].自动加点 = 内容.开关

			if self.数据[bh].自动加点 then
				常规提示(id, "#Y/你的#R" .. self.数据[bh].名称 .. "#P开启了#S自动加点#Y、升级后将按保存的加点方案分配潜力点")
			else
				常规提示(id, "#Y/你的#R" .. self.数据[bh].名称 .. "#P关闭了#S自动加点")
			end
		end
	elseif 序号 == 5005 then
		self:放生处理(连接id, 序号, id, 内容)
	elseif 序号 == 5005.1 then
		self:洗点处理(连接id, id, 内容.序列)
	elseif 序号 == 5005.2 then
		self:喂养处理(连接id, id, 内容.序列)
	elseif 序号 == 5006 then
		发送数据(连接id, 22, 玩家数据[id].角色.数据.宠物)
	elseif 序号 == 5007 then
		发送数据(连接id, 16, self.数据)

		if 玩家数据[id].角色.数据.道具行囊打开.道具 ~= nil then
			发送数据(连接id, 23, {
				道具 = 1
			})
		else
			发送数据(连接id, 23, 玩家数据[id].道具:索要道具2(id))
		end
	elseif 序号 == 5007.1 then
		系统处理类:打开交易中心(id)
	elseif 序号 == 5007.2 then
		if 玩家数据[id].角色.数据.自动战斗 == nil then
			玩家数据[id].角色.数据.自动战斗 = false
		end

		玩家数据[id].角色.数据.自动战斗 = not 玩家数据[id].角色.数据.自动战斗

		if 玩家数据[id].角色.数据.自动战斗 then
			常规提示(id, "#Y/下次进入战斗将：#P开启自动战斗")
		else
			常规提示(id, "#Y/下次进入战斗将：#P关闭自动战斗")
		end
	elseif 序号 == 5007.3 then
		if 玩家数据[id].角色.数据.战斗提示 == nil then
			玩家数据[id].角色.数据.战斗提示 = true
		end

		玩家数据[id].角色.数据.战斗提示 = not 玩家数据[id].角色.数据.战斗提示

		if 玩家数据[id].角色.数据.战斗提示 then
			常规提示(id, "#Y/你#P开启#Y了显示战斗提示文字")
		else
			常规提示(id, "#Y/你#P关闭#Y了显示战斗提示文字")
		end

		发送数据(连接id, 133.4, 玩家数据[id].角色.数据.战斗提示)
	elseif 序号 == 5007.4 then
		玩家数据[id].角色.数据.天气特效 = 内容.天气特效
	elseif 序号 == 5007.5 then
		取消其他自动(id, "挂机")

		if 自动挂机[id] ~= nil then
			自动挂机[id] = nil
			玩家数据[id].自动挂机 = false

			常规提示(id, "#Y/你#P关闭#Y了自动挂机")
			发送队伍挂机数据(id)
		else
			自动挂机[id] = 1

			置挂机详情(id)

			if 自动挂机[id] ~= nil then
				玩家数据[id].自动挂机 = true

				挂机自动飞行(id)
				常规提示(id, "#Y/你#P启动#Y了自动挂机")
				发送队伍挂机数据(id)
			end
		end
	elseif 序号 == 5007.6 then
		取消其他自动(id)
	elseif 序号 == 5007.7 then
		local 类型 = 内容.类型
		local 开关 = 内容.开关

		if 自动挂机[id] ~= nil then
			取消其他自动(id)

			玩家数据[id].自动挂机 = false

			常规提示(id, "#Y/你#P关闭#Y了自动挂机(")
			发送数据(玩家数据[id].连接id, 48.2, {
				自动挂机 = 玩家数据[id].自动挂机
			})
		end

		if 开关 == true then
			自动挂机列表[类型][id] = 1

			常规提示(id, "#Y/#R已勾选#Y自动挂机-#P" .. 类型)
		else
			自动挂机列表[类型][id] = nil

			常规提示(id, "#Y/#R已取消#Y自动挂机-#P" .. 类型)
		end

		发送数据(玩家数据[id].连接id, 7010.4, 取挂机详情(id))
	elseif 序号 == 5007.8 then
		if 自动挂机[id] ~= nil then
			取消其他自动(id)

			玩家数据[id].自动挂机 = false

			常规提示(id, "#Y/你#P关闭#Y了自动挂机(")
			发送数据(玩家数据[id].连接id, 48.2, {
				自动挂机 = 玩家数据[id].自动挂机
			})
		end

		local 参数 = 内容.参数
		local 开关 = 1
		local 条件 = nil
		local 提示 = "#P已勾选#Y全部挂机类型"

		if 参数 == 2 then
			开关 = nil
			提示 = "#P已取消勾选#Y全部挂机类型"
		elseif 参数 == 3 then
			条件 = 1
			提示 = "#P已勾选#Y全部任务挂机类型"
		elseif 参数 == 4 then
			条件 = 1
			开关 = nil
			提示 = "#P已取消勾选#Y全部任务挂机类型"
		elseif 参数 == 5 then
			条件 = 2
			提示 = "#P已勾选#Y全部场景挂机类型"
		elseif 参数 == 6 then
			条件 = 2
			开关 = nil
			提示 = "#P已取消勾选#Y全部场景挂机类型"
		end

		for k, v in pairs(自动挂机类型列表1) do
			if 自动挂机列表[k] ~= nil and (条件 == nil or v == 条件) then
				自动挂机列表[k][id] = 开关
			end
		end

		常规提示(id, 提示)
		发送数据(玩家数据[id].连接id, 7010.4, 取挂机详情(id))
	elseif 序号 == 5007.9 then
		local 开通挂机月卡 = false

		if 单机设置 then
			开通挂机月卡 = true
		else
			local 消耗点卡 = 1000

			if 玩家数据[id].角色:扣除点卡(消耗点卡, "购买挂机月卡", id) == false then
				return 常规提示(id, "#P激活/续费#Y挂机月卡需要" .. 消耗点卡 .. "点卡")
			else
				开通挂机月卡 = true
			end
		end

		if 开通挂机月卡 == true then
			if 玩家数据[id].角色.数据.挂机月卡 ~= nil and 玩家数据[id].角色.数据.挂机月卡 >= 1 then
				玩家数据[id].角色.数据.挂机月卡 = 1
				玩家数据[id].角色.数据.挂机时间限制 = math.max(玩家数据[id].角色.数据.挂机时间限制 or 0, os.time()) + 2592000

				常规提示(id, "恭喜您续费#P挂机月卡#Y成功")
			elseif 玩家数据[id].角色.数据.挂机月卡 == nil or 玩家数据[id].角色.数据.挂机月卡 == 0 then
				玩家数据[id].角色.数据.挂机月卡 = 1
				玩家数据[id].角色.数据.挂机时间限制 = os.time() + 2592000

				常规提示(id, "恭喜您成功激活了#P挂机月卡#Y")
			end

			发送数据(玩家数据[id].连接id, 133.5, {
				挂机月卡 = 玩家数据[id].角色.数据.挂机月卡,
				到期时间 = 玩家数据[id].角色.数据.挂机时间限制,
				点卡 = 取点卡数据(id)
			})
		end
	elseif 序号 == 5008 then
		self:洗练处理(连接id, 序号, id, 内容)
	elseif 序号 == 5008.3 then
		self:洗练处理(连接id, 序号, id, 内容)
	elseif 序号 == 5008.1 then
		self:打书确认(连接id, 序号, id, 内容)
	elseif 序号 == 5008.2 then
		self:洗练处理(连接id, 序号, id, 内容)
	elseif 序号 == 5027 then
		self:洗练处理(连接id, 序号, id, 内容)
	elseif 序号 == 5009 then
		self:合宠处理(连接id, 序号, id, 内容)
	elseif 序号 == 5010 then
		self:炼化处理(连接id, 序号, id, 内容)
	elseif 序号 == 5011 then
		self:召唤兽染色(连接id, 序号, id, 内容)
	elseif 序号 == 5012 then
		self:召唤兽饰品染色(连接id, 序号, id, 内容)
	elseif 序号 == 5015.1 then
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 151)
	elseif 序号 == 5015 then
		发送数据(连接id, 3526, {
			召唤兽 = self.数据,
			召唤兽仓库总数 = #玩家数据[id].召唤兽仓库.数据,
			召唤兽仓库数据 = 玩家数据[id].召唤兽仓库:索取召唤兽仓库数据(id, 1)
		})
	elseif 序号 == 5016 then
		发送数据(连接id, 16, self.数据)

		if 玩家数据[id].角色.数据.道具行囊打开.道具 ~= nil then
			发送数据(连接id, 152, {
				道具 = 1
			})
		else
			发送数据(连接id, 152, 玩家数据[id].道具:索要道具2(id))
		end
	elseif 序号 == 5017 then
		发送数据(连接id, 16, self.数据)

		if 玩家数据[id].角色.数据.道具行囊打开.道具 ~= nil then
			发送数据(连接id, 153, {
				道具 = 1
			})
		else
			发送数据(连接id, 153, 玩家数据[id].道具:索要道具2(id))
		end
	elseif 序号 == 5020 then
		发送数据(连接id, 119, self.数据)
	elseif 序号 == 5020.1 then
		发送数据(连接id, 119.1, 玩家数据[id].角色.数据.坐骑列表 or {})
	elseif 序号 == 5026 then
		self:图鉴属性()
	end
end

bb技能评分 = {
	高级助攻 = 400,
	上古灵符 = 800,
	永恒 = 150,
	高级迟钝 = 300,
	水属性吸收 = 150,
	法术抵抗 = 150,
	恐怖 = 150,
	审判 = 150,
	高级水属性吸收 = 300,
	高级法术助攻 = 400,
	鬼魂术 = 150,
	高级隐身 = 300,
	高级再生 = 300,
	开门见山 = 1000,
	精神集中 = 150,
	超级偷袭 = 1000,
	高级遗志 = 300,
	高级合纵 = 300,
	震摄 = 150,
	高级鬼魂术 = 300,
	神迹 = 150,
	高级冥思 = 300,
	超级强力 = 900,
	迟钝 = 150,
	圣婴大王 = 1500,
	报复 = 150,
	土属性吸收 = 150,
	仙人指路 = 1000,
	高级神佑复生 = 500,
	高级法术连击 = 400,
	盾气 = 150,
	超级土属性吸收 = 800,
	高级魔法反击 = 300,
	魔之心 = 200,
	法术连击 = 200,
	魔法反击 = 150,
	超级再生 = 800,
	高级法术波动 = 400,
	超级进击法爆 = 900,
	高级连击 = 400,
	连击 = 200,
	高级勇敢 = 300,
	高级飞行 = 300,
	气势 = 150,
	高级报复 = 300,
	高级否定信仰 = 300,
	高级法术穿透 = 400,
	进击法爆 = 200,
	峰回路转 = 1000,
	遗志 = 150,
	奋勇当先 = 1200,
	反击 = 150,
	烈焰斩 = 600,
	弱点火 = 50,
	高级雷属性吸收 = 300,
	移花接木 = 400,
	火属性吸收 = 150,
	冥思 = 150,
	高级健壮 = 400,
	高级保命 = 300,
	高级神迹 = 300,
	高级恐吓 = 300,
	高级恐怖 = 300,
	法术助攻 = 200,
	诸天正法 = 800,
	扶摇万里 = 800,
	超级必杀 = 1000,
	超级飞行 = 1000,
	千钧一怒 = 800,
	超级感知 = 800,
	溜之大吉 = 800,
	昼伏夜出 = 800,
	凝光炼彩 = 800,
	好梦连连 = 1500,
	强力 = 150,
	逍遥游 = 800,
	薪火相传 = 800,
	泡泡相伴 = 800,
	高级进击法爆 = 400,
	蚩尤之搏 = 1000,
	高级审判 = 300,
	驱怪 = 800,
	赶尽杀绝 = 500,
	张弛有道 = 1000,
	高级法术暴击 = 500,
	上善若水 = 600,
	生命守护 = 600,
	吸血 = 200,
	理直气壮 = 800,
	超级进击必杀 = 900,
	赴汤蹈火 = 1000,
	超级吸血 = 900,
	飞行 = 150,
	弱点土 = 50,
	偷袭 = 200,
	超级夜战 = 1000,
	超级毒 = 900,
	高级必杀 = 500,
	刀背打 = 500,
	法术波动 = 150,
	超级驱鬼 = 900,
	超级反震 = 800,
	神来气旺 = 800,
	超级法术抵抗 = 900,
	神佑复生 = 250,
	超级幸运 = 900,
	超级精神集中 = 800,
	助攻 = 200,
	幸运 = 150,
	冰霜 = 150,
	招架 = 150,
	从天而降 = 800,
	超级慧根 = 800,
	逆击 = 150,
	高级招架 = 300,
	超级神迹 = 800,
	神武盾气 = 150,
	风起龙游 = 800,
	高级震摄 = 300,
	超级永恒 = 800,
	超级遗志 = 800,
	烈火 = 200,
	超级魔之心 = 900,
	超级法术波动 = 900,
	高级驱鬼 = 300,
	高级气势 = 300,
	超级敏捷 = 1000,
	超级雷属性吸收 = 800,
	高级反震 = 300,
	弱点雷 = 50,
	高级冲击 = 300,
	恐吓 = 150,
	高级强力 = 300,
	高级魔之心 = 400,
	高级永恒 = 300,
	高级火属性吸收 = 300,
	超级火属性吸收 = 800,
	超级连击 = 900,
	荒古破击 = 800,
	高级毒 = 300,
	壁垒击破 = 800,
	高级偷袭 = 400,
	超级地狱烈火 = 1000,
	超级壁垒击破 = 1300,
	保命 = 150,
	高级土属性吸收 = 300,
	合纵 = 150,
	雷击 = 200,
	灵山禅语 = 800,
	物理穿透 = 200,
	高级进击必杀 = 400,
	再生 = 150,
	高级精神集中 = 300,
	勇敢 = 150,
	法术暴击 = 250,
	须弥真言 = 800,
	净台妙谛 = 800,
	高级感知 = 300,
	["剑气四射·觉醒"] = 1000,
	高级盾气 = 300,
	否定信仰 = 150,
	高级防御 = 300,
	毒 = 150,
	进击必杀 = 200,
	奔雷咒 = 500,
	虎虎生风 = 800,
	泰山压顶 = 500,
	大快朵颐 = 1200,
	地狱烈火 = 500,
	["饕餮盛宴·觉醒"] = 1000,
	天降灵葫 = 800,
	健壮 = 200,
	八凶法阵 = 800,
	高级幸运 = 300,
	感知 = 150,
	防御 = 150,
	苍鸾怒击 = 800,
	叱咤风云 = 800,
	食指大动 = 800,
	高级冰霜 = 300,
	观照万象 = 1000,
	雨润丰泽 = 800,
	驱鬼 = 150,
	龙魂 = 800,
	惊心一剑 = 800,
	夜战 = 200,
	善恶有报 = 800,
	力劈华山 = 800,
	高级强壮 = 400,
	死亡召唤 = 800,
	超级反击 = 900,
	高级神武盾气 = 300,
	慧根 = 150,
	弱点水 = 50,
	水击三千 = 800,
	高级逆击 = 300,
	雷属性吸收 = 150,
	反震 = 150,
	超级水属性吸收 = 800,
	高级物理穿透 = 400,
	出其不意 = 800,
	高级敏捷 = 400,
	隐身 = 150,
	夜舞倾城 = 800,
	灵能激发 = 800,
	超级合纵 = 1000,
	高级夜战 = 400,
	津津有味 = 800,
	高级法术抵抗 = 300,
	法术防御 = 800,
	无畏布施 = 800,
	敏捷 = 200,
	神出鬼没 = 800,
	舍身一搏 = 800,
	超级水漫金山 = 1000,
	超级法术暴击 = 1000,
	双星闪 = 800,
	影袭 = 600,
	法术穿透 = 200,
	剑气四射 = 500,
	四面埋伏 = 1000,
	水漫金山 = 500,
	必杀 = 250,
	饕餮盛宴 = 800,
	浮云神马 = 800,
	落岩 = 200,
	高级蛮劲 = 400,
	高级反击 = 300,
	剑荡四方 = 800,
	超级法术连击 = 900,
	蛮劲 = 200,
	翻江倒海 = 800,
	超级招架 = 800,
	超级泰山压顶 = 1000,
	超级防御 = 900,
	超级隐身 = 900,
	桀骜自恃 = 1500,
	超级否定信仰 = 800,
	治疗 = 1000,
	水攻 = 200,
	千锤百炼 = 1000,
	焚天陨火 = 1500,
	超级冥思 = 800,
	月光 = 800,
	嗜血追击 = 800,
	风沙之盾 = 600,
	高级慧根 = 300,
	还魂咒 = 1000,
	超级盾气 = 800,
	超级三昧真火 = 1200,
	高级吸血 = 400,
	迅风出击 = 1200,
	超级奔雷咒 = 1000,
	冲击 = 150,
	流沙轻音 = 800,
	战斗号角 = 600
}
BB资质 = {
	速度资质 = 2.5,
	躲闪资质 = 0.5,
	体力资质 = 1,
	法力资质 = 1.5,
	攻击资质 = 2.5,
	防御资质 = 2.5,
	成长 = 3000
}

取召唤兽排行榜评分 = function(bb数据, 主人名称)
	if bb数据 ~= nil and not 判断是否为空表(bb数据) then
		bb评分 = 0

		for k, v in pairs(BB资质) do
			bb评分 = bb评分 + bb数据[k] * v
		end

		bbjn = {}

		if bb数据.法术认证 ~= nil and bb数据.法术认证[2] ~= nil then
			bbjn[1] = bb数据.法术认证[2]
		end

		if bb数据.护符附带技能 ~= nil and not 判断是否为空表(bb数据.护符附带技能) then
			bbjn = 列表2加入到列表1(bbjn, bb数据.护符附带技能)
		end

		bbjn = 列表2加入到列表1(bbjn, bb数据.技能)

		删除重复(bbjn)

		for i = 1, #bbjn do
			if bb技能评分[bbjn[i]] ~= nil then
				bb评分 = bb评分 + bb技能评分[bbjn[i]]
			end
		end

		bb评分 = bb评分 + bb数据.灵性 * 5

		if bb数据.灵性 >= 110 then
			bb评分 = bb评分 + 500
		end

		if bb数据.特性几率 > 0 then
			bb评分 = bb评分 + bb数据.特性几率 * 80
		end

		bb评分 = qz1(bb评分)
		bb数据.评分 = bb评分 + 0

		刷新召唤兽排行榜(bb数据, 主人名称, bb评分)
	end
end

function 召唤兽处理类:加载数据(账号, 数字id)
	self.数字id = 数字id
	self.数据 = table.loadstring(读入文件("data/" .. 账号 .. "/" .. 数字id .. "/召唤兽.txt"))
	local 高于等级 = 召唤兽参战高于等级

	if 玩家数据[数字id].角色.数据.飞升 == true then
		高于等级 = 召唤兽参战高于等级 + 飞升高于等级
	end

	for i = 1, #self.数据 do
		if self.数据[i] ~= nil then
			if self.数据[i].统御属性 == nil then
				self.数据[i].统御属性 = {
					体质 = 0,
					力量 = 0,
					敏捷 = 0,
					耐力 = 0,
					魔力 = 0
				}
			end

			if self.数据[i].种类 == "神兽" then
				for k, v in pairs(神兽资质上限) do
					if v < self.数据[i][k] then
						self.数据[i][k] = v

						常规提示(数字id, "当前版本神兽宠物最高#S" .. k .. "#Y不能>#R" .. v .. "#Y、你的宝宝#S" .. k .. "#Y已经被强制修改为#P" .. v)
					end
				end
			else
				for k, v in pairs(资质上限) do
					if v < self.数据[i][k] then
						self.数据[i][k] = v

						常规提示(数字id, "当前版本宠物最高#S" .. k .. "#Y不能>#R" .. v .. "#Y、你的宝宝#S" .. k .. "#Y已经被强制修改为#P" .. v)
					end
				end
			end

			if (self.数据[i].护符技能 == nil or 判断是否为空表(self.数据[i].护符技能)) and self.数据[i].装备 ~= nil and self.数据[i].装备[4] ~= nil and self.数据[i].装备[4].附带技能 ~= nil then
				self.数据[i].护符技能 = {}

				for n = 1, #self.数据[i].装备[4].附带技能 do
					self.数据[i].护符技能[n] = self.数据[i].装备[4].附带技能[n]
				end
			end

			if self.数据[i].装备 ~= nil then
				for k, v in pairs(self.数据[i].装备) do
					if v.特效 ~= nil then
						if type(v.特效) ~= "table" then
							v.特效 = {
								v.特效 .. ""
							}
						elseif 判断是否为空表(v.特效) then
							v.特效 = nil
						end
					end

					if v.第二特效 ~= nil then
						v.特效 = v.特效 or {}
						v.特效[#v.特效 + 1] = v.第二特效 .. ""
						v.第二特效 = nil
					end
				end
			end

			if 玩家数据[数字id].角色.数据.等级 < self.数据[i].等级 - 高于等级 or 召唤兽最高等级 < self.数据[i].等级 then
				self.数据[i].等级 = math.min(玩家数据[数字id].角色.数据.等级 + 高于等级, 召唤兽最高等级)

				self:洗点处理1(i)
				常规提示(数字id, "#Y你的#R" .. self.数据[i].名称 .. "#Y等级过高，系统自动进行了降级处理。")
			end

			if 单机设置 then
				if self.数据[i].宠物图鉴系统 ~= nil then
					self.数据[i].宠物图鉴系统 = nil
				end

				if self.数据[i].模型 == "魔化童子" then
					self.数据[i].模型 = "魔化毗舍童子"
				elseif self.数据[i].模型 == "小仙灵" then
					self.数据[i].模型 = "小神灵"
				elseif self.数据[i].模型 == "进阶小仙灵" then
					self.数据[i].模型 = "进阶小神灵"
				elseif self.数据[i].模型 == "葵卯神兔" then
					self.数据[i].模型 = "癸卯神兔"
				elseif self.数据[i].模型 == "进阶葵卯神兔" then
					self.数据[i].模型 = "进阶癸卯神兔"
				elseif self.数据[i].模型 == "Q版魔化童子" then
					self.数据[i].模型 = "Q版魔化毗舍童子"
				end
			end

			if 玩家数据[数字id].角色.数据.参战宝宝 == nil then
				玩家数据[数字id].角色.数据.参战宝宝 = {}
			end

			if not 判断是否为空表(玩家数据[数字id].角色.数据.参战宝宝) and 玩家数据[数字id].角色.数据.参战宝宝.认证码 ~= nil and self.数据[i].认证码 == 玩家数据[数字id].角色.数据.参战宝宝.认证码 then
				if 玩家数据[数字id].角色.数据.参战宝宝.等级 - 高于等级 > 玩家数据[数字id].角色.数据.等级 + 0 then
					玩家数据[数字id].角色.数据.参战宝宝 = {}
					self.数据[i].参战信息 = nil
					玩家数据[数字id].角色.数据.参战信息 = nil
				else
					玩家数据[数字id].角色.数据.参战宝宝 = {}
					玩家数据[数字id].角色.数据.参战宝宝 = self.数据[i]
					玩家数据[数字id].角色.数据.参战信息 = 1
					self.数据[i].参战信息 = 1
				end
			end

			self:刷新套装效果(i)
			取召唤兽排行榜评分(self.数据[i], 玩家数据[数字id].角色.数据.名称)
		end
	end
end

function 召唤兽处理类:添加召唤兽(造型, 宝宝, 变异, 神兽, 等级, 物法, 位置, vip, 技能组, 超级金柳露, 绑定, 其他参数)
	local 编号 = nil
	local 孩子 = false

	if 等级 == nil then
		等级 = 0
	end

	if 变异 == "变异" or 变异 == true then
		变异 = true
	else
		变异 = false
	end

	if 宝宝 == "宝宝" or 宝宝 == "变异" then
		宝宝 = true

		if 宝宝 == "变异" then
			变异 = true
		end
	elseif 宝宝 == "野怪" then
		宝宝 = false
		变异 = false
	elseif 宝宝 == "孩子" then
		孩子 = true
	end

	if 位置 == nil then
		self.数据[#self.数据 + 1] = {
			特性 = "无",
			进阶 = false,
			寿命 = 5000,
			特性几率 = 0,
			当前经验 = 0,
			忠诚 = 100,
			仙露上限 = 7,
			灵性 = 0,
			模型 = 造型,
			名称 = 造型,
			等级 = 等级 or 0,
			潜力 = 等级 * 服务端参数.宝宝升级潜能点 or 0,
			装备 = {},
			染色组 = {},
			装备属性 = {
				魔力 = 0,
				体质 = 0,
				力量 = 0,
				气血 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔法 = 0,
				躲避 = 0,
				灵力 = 0,
				伤害 = 0,
				速度 = 0,
				命中 = 0,
				防御 = 0
			},
			进阶属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			统御属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			五行 = 五行_[取随机数(1, 5)]
		}
		编号 = #self.数据
	else
		self.数据[位置] = {
			特性 = "无",
			进阶 = false,
			寿命 = 5000,
			特性几率 = 0,
			当前经验 = 0,
			忠诚 = 100,
			仙露上限 = 7,
			灵性 = 0,
			模型 = 造型,
			名称 = 造型,
			等级 = 等级 or 0,
			潜力 = 等级 * 服务端参数.宝宝升级潜能点 or 0,
			装备 = {},
			染色组 = {},
			装备属性 = {
				魔力 = 0,
				体质 = 0,
				力量 = 0,
				气血 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔法 = 0,
				躲避 = 0,
				灵力 = 0,
				伤害 = 0,
				速度 = 0,
				命中 = 0,
				防御 = 0
			},
			进阶属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			统御属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			五行 = 五行_[ygsj(5)]
		}
		编号 = 位置
	end

	if 神兽 then
		local qss = nil
		qss = 取神兽资质(造型, 物法)
		qss[9] = {
			200,
			40,
			40,
			40,
			40,
			40
		}
		self.数据[编号].种类 = "神兽"
		self.数据[编号].名称 = "神兽·" .. 造型
		self.数据[编号].天生神兽 = true

		if 孩子 then
			self.数据[编号].种类 = "孩子"
			self.数据[编号].名称 = 造型
			self.数据[编号].天生神兽 = nil
		end

		for i = 1, #资质范围 do
			self.数据[编号][资质范围[i]] = qss[i] or 0
		end

		self.数据[编号].技能 = qss[8]
		self.数据[编号].成长 = qss[7]
		self.数据[编号].参战等级 = 0
		self.数据[编号].内丹 = {
			可用内丹 = 6,
			内丹上限 = 6
		}
		self.数据[编号].饰品 = nil
		self.数据[编号].潜力 = 0

		for i = 1, #属性范围 do
			self.数据[编号][属性范围[i]] = qss[9][i + 1] or 0
		end

		self.数据[编号].认证码 = self.数字id .. "_" .. os.time() .. "_" .. 服务端参数.运行时间 .. "_" .. 取随机数(111111111111.0, 999999999999.0)
	else
		local n = bbs(造型)

		if #n <= 5 then
			n = bbs("泡泡")
		end

		local 类型 = nil
		local 是否变异 = 变异
		local 波动上限 = 1
		local 能力 = 0.8

		if 超级金柳露 == 1 then
			波动上限 = 波动上限 + 0.05
			能力 = 能力 + 0.05
		end

		local 五维总值 = 0

		if 宝宝 then
			类型 = "宝宝"
			self.数据[编号].种类 = "宝宝"
			self.数据[编号].名称 = 造型

			if 是否变异 then
				能力 = 能力 + 0.05

				if ygsj() <= 1 then
					波动上限 = 波动上限 + 0.05
				end

				self.数据[编号].变异 = true
				self.数据[编号].种类 = "变异"
				self.数据[编号].名称 = "变异" .. 造型

				if 染色信息[造型] ~= nil then
					self.数据[编号].染色方案 = 染色信息[造型].id

					for i = 1, 3 do
						if 染色信息[造型].方案[i] ~= nil then
							self.数据[编号].染色组[i] = 染色信息[造型].方案[i]
						end
					end
				end
			end

			self.数据[编号].攻击资质 = qz1(n[2] * rand(能力, 波动上限))
			self.数据[编号].防御资质 = qz1(n[3] * rand(能力, 波动上限))
			self.数据[编号].体力资质 = qz1(n[4] * rand(能力, 波动上限))
			self.数据[编号].法力资质 = qz1(n[5] * rand(能力, 波动上限))
			self.数据[编号].速度资质 = qz1(n[6] * rand(能力, 波动上限))
			self.数据[编号].躲闪资质 = qz1(n[7] * rand(能力, 波动上限))
			local cz1 = 取随机数(1, 100)

			if cz1 < 30 then
				self.数据[编号].成长 = n[8][1]
			elseif cz1 > 30 and cz1 < 60 then
				self.数据[编号].成长 = n[8][2]
			elseif cz1 > 60 and cz1 < 80 then
				self.数据[编号].成长 = n[8][3]
			elseif cz1 > 80 and cz1 < 95 then
				self.数据[编号].成长 = n[8][4]
			elseif cz1 > 95 and cz1 < 100 then
				self.数据[编号].成长 = n[8][5]
			end

			if self.数据[编号].成长 == nil or self.数据[编号].成长 == 0 then
				self.数据[编号].成长 = n[8][1]
			end
		else
			类型 = "野怪"
			self.数据[编号].潜力 = 0
			self.数据[编号].种类 = "野怪"
			能力 = 0.725
			五维总值 = (等级 + 10) * 5 + 等级 * 服务端参数.宝宝升级潜能点
		end

		self.数据[编号].参战等级 = n[1]

		if 类型 == "野怪" then
			能力 = 能力 - 0.3
			local s6 = 五维总值 - (等级 + 10) * 5
			local s1, s2, s3, s4, s5 = nil
			s1 = 取随机数(等级 + 10, 等级 + 10 + s6)
			s6 = s6 - (s1 - (等级 + 10))
			s2 = 取随机数(等级 + 10, 等级 + 10 + s6)
			s6 = s6 - (s2 - (等级 + 10))
			s3 = 取随机数(等级 + 10, 等级 + 10 + s6)
			s6 = s6 - (s3 - (等级 + 10))
			s4 = 取随机数(等级 + 10, 等级 + 10 + s6)
			s6 = s6 - (s4 - (等级 + 10))
			s5 = 等级 + 10 + s6
			s1 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
			s2 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
			s3 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
			s4 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
			s5 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
			self.数据[编号].体质 = s1
			self.数据[编号].魔力 = s2
			self.数据[编号].力量 = s3
			self.数据[编号].耐力 = s4
			self.数据[编号].敏捷 = s5
			self.数据[编号].攻击资质 = ceil(n[2] * rand(能力, 波动上限))
			self.数据[编号].防御资质 = ceil(n[3] * rand(能力, 波动上限))
			self.数据[编号].体力资质 = ceil(n[4] * rand(能力, 波动上限))
			self.数据[编号].法力资质 = ceil(n[5] * rand(能力, 波动上限))
			self.数据[编号].速度资质 = ceil(n[6] * rand(能力, 波动上限))
			self.数据[编号].躲闪资质 = ceil(n[7] * rand(能力, 波动上限))
			local cz1 = 取随机数(1, 100)

			if cz1 < 30 then
				self.数据[编号].成长 = n[8][1]
			elseif cz1 > 30 and cz1 < 60 then
				self.数据[编号].成长 = n[8][2]
			elseif cz1 > 60 and cz1 < 80 then
				self.数据[编号].成长 = n[8][3]
			elseif cz1 > 80 and cz1 < 95 then
				self.数据[编号].成长 = n[8][4]
			elseif cz1 > 95 and cz1 < 100 then
				self.数据[编号].成长 = n[8][5]
			end

			if self.数据[编号].成长 == nil or self.数据[编号].成长 == 0 then
				self.数据[编号].成长 = n[8][1]
			end
		end

		if 技能组 ~= nil then
			self.数据[编号].技能 = cfs(技能组)
		else
			self.数据[编号].技能 = 取洗宠技能(self.数据[编号].模型, self.数据[编号].变异, n[9], 超级金柳露)
		end

		self.数据[编号].饰品 = nil
		self.数据[编号].内丹 = {
			可用内丹 = 6,
			内丹上限 = 6
		}
		self.数据[编号].认证码 = self.数字id .. "_" .. os.time() .. "_" .. 服务端参数.运行时间 .. "_" .. 取随机数(111111111111.0, 999999999999.0)
	end

	if 绑定 == true then
		self.数据[编号].不可交易 = true
	end

	if #self.数据[编号].名称 > 16 then
		self.数据[编号].名称 = 造型
	end

	if 五行固定召唤兽[string.gsub(造型, "进阶", "")] ~= nil then
		self.数据[编号].五行 = 五行固定召唤兽[string.gsub(造型, "进阶", "")] .. ""
	end

	if 其他参数 ~= nil and type(其他参数) == "table" then
		if 其他参数.胚子 ~= nil then
			self.数据[编号].攻击资质 = 1550
			self.数据[编号].防御资质 = 1550
			self.数据[编号].体力资质 = 5500
			self.数据[编号].法力资质 = 3500
			self.数据[编号].速度资质 = 1550
			self.数据[编号].躲闪资质 = 1550
			self.数据[编号].成长 = 1.275
			self.数据[编号].不可交易 = true
		elseif 其他参数.神宠 ~= nil then
			self.数据[编号].攻击资质 = 1550
			self.数据[编号].防御资质 = 1550
			self.数据[编号].体力资质 = 5500
			self.数据[编号].法力资质 = 3500
			self.数据[编号].速度资质 = 1550
			self.数据[编号].躲闪资质 = 1550
			self.数据[编号].成长 = 1.275
			self.数据[编号].种类 = "神兽"
			self.数据[编号].天生神兽 = true
			self.数据[编号].不可交易 = true
		elseif 其他参数.自选神兽 ~= nil then
			self.数据[编号].攻击资质 = 1550
			self.数据[编号].防御资质 = 1550
			self.数据[编号].体力资质 = 5500
			self.数据[编号].法力资质 = 3500
			self.数据[编号].速度资质 = 1550
			self.数据[编号].躲闪资质 = 1550
			self.数据[编号].成长 = 1.275
			self.数据[编号].不可交易 = true
		end
	end

	if self.数据[编号].种类 ~= "野怪" then
		self:洗点处理1(编号)
	else
		self:刷新信息(编号, "1")
	end

	发送数据(玩家数据[self.数字id].连接id, 17.1, self.数据)
end

function 召唤兽处理类:添加新手召唤兽(造型, 宝宝, 变异, 神兽, 等级, 物法, 位置, vip)
	local 编号 = nil

	if 宝宝 == "宝宝" or 宝宝 == "变异" then
		宝宝 = true

		if 变异 == "变异" then
			变异 = true
		else
			变异 = false
		end
	elseif 宝宝 == "野怪" then
		宝宝 = false
	end

	if 位置 == nil then
		self.数据[#self.数据 + 1] = {
			特性 = "无",
			进阶 = false,
			不可交易 = true,
			当前经验 = 0,
			寿命 = 5000,
			特性几率 = 0,
			忠诚 = 100,
			仙露上限 = 7,
			灵性 = 0,
			模型 = 造型,
			名称 = 造型,
			等级 = 等级 or 0,
			潜力 = 等级 * 服务端参数.宝宝升级潜能点 or 0,
			装备 = {},
			染色组 = {},
			装备属性 = {
				魔力 = 0,
				体质 = 0,
				力量 = 0,
				气血 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔法 = 0,
				躲避 = 0,
				灵力 = 0,
				伤害 = 0,
				速度 = 0,
				命中 = 0,
				防御 = 0
			},
			进阶属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			统御属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			五行 = 五行_[取随机数(1, 5)]
		}
		编号 = #self.数据
	else
		self.数据[位置] = {
			特性 = "无",
			进阶 = false,
			不可交易 = true,
			当前经验 = 0,
			寿命 = 5000,
			特性几率 = 0,
			忠诚 = 100,
			仙露上限 = 7,
			灵性 = 0,
			模型 = 造型,
			名称 = 造型,
			等级 = 等级 or 0,
			潜力 = 等级 * 服务端参数.宝宝升级潜能点 or 0,
			装备 = {},
			染色组 = {},
			装备属性 = {
				魔力 = 0,
				体质 = 0,
				力量 = 0,
				气血 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔法 = 0,
				躲避 = 0,
				灵力 = 0,
				伤害 = 0,
				速度 = 0,
				命中 = 0,
				防御 = 0
			},
			进阶属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			统御属性 = {
				体质 = 0,
				力量 = 0,
				敏捷 = 0,
				耐力 = 0,
				魔力 = 0
			},
			五行 = 五行_[取随机数(1, 5)]
		}
		编号 = 位置
	end

	if 神兽 then
		local qss = nil
		qss = 取神兽资质(造型, 物法)
		self.数据[编号].种类 = "神兽"

		for i = 1, #资质范围 do
			self.数据[编号][资质范围[i]] = qss[i] or 0
		end

		self.数据[编号].技能 = qss[8]
		self.数据[编号].成长 = qss[7]
		self.数据[编号].参战等级 = 0
		self.数据[编号].内丹 = {
			可用内丹 = 3,
			内丹上限 = 3
		}
		self.数据[编号].饰品 = nil
		self.数据[编号].潜力 = 0

		for i = 1, #属性范围 do
			self.数据[编号][属性范围[i]] = qss[9][i + 1] or 0
		end

		self.数据[编号].认证码 = self.数字id .. "_" .. os.time() .. "_" .. 服务端参数.运行时间 .. "_" .. 取随机数(111111111111.0, 999999999999.0)
		self.数据[编号].不可交易 = true
	else
		local n = bbs(造型)
		local 类型 = nil
		local 是否变异 = 变异
		local 波动上限 = 1
		local 能力 = 0
		local 五维总值 = 0

		if 宝宝 then
			类型 = "宝宝"
			能力 = 0.925
			self.数据[编号].种类 = "宝宝"

			if 是否变异 then
				能力 = 1.105
				n[2] = n[2] + 80
				n[3] = n[3] + 80
				n[4] = n[4] + 80
				n[5] = n[5] + 80
				n[6] = n[6] + 80
				n[7] = n[7] + 80
				self.数据[编号].变异 = true
				self.数据[编号].种类 = "变异"
				self.数据[编号].名称 = "变异" .. 造型

				if 染色信息[造型] ~= nil then
					self.数据[编号].染色方案 = 染色信息[造型].id

					for i = 1, 3 do
						if 染色信息[造型].方案[i] ~= nil then
							self.数据[编号].染色组[i] = 染色信息[造型].方案[i]
						end
					end
				end
			end
		else
			类型 = "野怪"
			self.数据[编号].潜力 = 0
			self.数据[编号].种类 = "野怪"
			能力 = 0.725
			五维总值 = 野怪初始潜力 * 5 + 等级 * 服务端参数.宝宝升级潜能点
		end

		self.数据[编号].参战等级 = n[1]

		if 类型 == "野怪" then
			local s1, s2, s3, s4, s5, s6 = nil

			while true do
				s1 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
				s2 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
				s3 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
				s4 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))
				s5 = 取随机数(五维总值 / 10, ceil(五维总值 / 3))

				if s1 + s2 + s3 + s4 + s5 == 五维总值 then
					self.数据[编号].体质 = s1
					self.数据[编号].魔力 = s2
					self.数据[编号].力量 = s3
					self.数据[编号].耐力 = s4
					self.数据[编号].敏捷 = s5

					break
				end
			end
		end

		self.数据[编号].攻击资质 = ceil(n[2] * rand(能力, 波动上限))
		self.数据[编号].防御资质 = ceil(n[3] * rand(能力, 波动上限))
		self.数据[编号].体力资质 = ceil(n[4] * rand(能力, 波动上限))
		self.数据[编号].法力资质 = ceil(n[5] * rand(能力, 波动上限))
		self.数据[编号].速度资质 = ceil(n[6] * rand(能力, 波动上限))
		self.数据[编号].躲闪资质 = ceil(n[7] * rand(能力, 波动上限))
		local cz1 = 取随机数(1, 100)

		if cz1 < 30 then
			self.数据[编号].成长 = n[8][1]
		elseif cz1 > 30 and cz1 < 60 then
			self.数据[编号].成长 = n[8][2]
		elseif cz1 > 60 and cz1 < 80 then
			self.数据[编号].成长 = n[8][3]
		elseif cz1 > 80 and cz1 < 95 then
			self.数据[编号].成长 = n[8][4]
		elseif cz1 > 95 and cz1 < 100 then
			self.数据[编号].成长 = n[8][5]
		end

		if self.数据[编号].成长 == nil or self.数据[编号].成长 == 0 then
			self.数据[编号].成长 = n[8][1]
		end

		local jn = n[9]
		local jn0 = {}

		for q = 1, #jn do
			insert(jn0, jn[取随机数(1, #jn)])
		end

		jn0 = cfs(jn0)
		self.数据[编号].技能 = jn0
		self.数据[编号].饰品 = nil
		self.数据[编号].内丹 = {
			可用内丹 = 6,
			内丹上限 = 6
		}
		self.数据[编号].认证码 = self.数字id .. "_" .. os.time() .. "_" .. 服务端参数.运行时间 .. "_" .. 取随机数(111111111111.0, 999999999999.0)
		self.数据[编号].不可交易 = true
	end

	if self.数据[编号].种类 ~= "野怪" then
		self:洗点处理1(编号)
	else
		self:刷新信息(编号, "1")
	end

	发送数据(玩家数据[self.数字id].连接id, 17.1, self.数据)
end

function 召唤兽处理类:图鉴属性()
	local 编号 = nil

	if os.time() - 玩家数据[self.数字id].角色.数据.刷新时间 < 10 then
		常规提示(self.数字id, "#Y每次刷新时间间隔10秒")

		return
	end

	if 玩家数据[self.数字id].召唤兽.数据[1] ~= nil then
		for h, v in pairs(玩家数据[self.数字id].召唤兽.数据) do
			编号 = h
			self.数据[编号].宠物图鉴属性 = {
				躲闪资质 = 0,
				体质 = 0,
				体力资质 = 0,
				速度 = 0,
				力量 = 0,
				防御 = 0,
				成长 = 0,
				灵力 = 0,
				速度资质 = 0,
				法力资质 = 0,
				魔力 = 0,
				最大魔法 = 0,
				敏捷 = 0,
				最大气血 = 0,
				耐力 = 0,
				伤害 = 0,
				攻击资质 = 0,
				防御资质 = 0
			}
			local 发送数据 = {
				躲闪资质 = 0,
				体质 = 0,
				体力资质 = 0,
				速度 = 0,
				力量 = 0,
				防御 = 0,
				成长 = 0,
				灵力 = 0,
				速度资质 = 0,
				法力资质 = 0,
				魔力 = 0,
				最大魔法 = 0,
				敏捷 = 0,
				最大气血 = 0,
				耐力 = 0,
				伤害 = 0,
				攻击资质 = 0,
				防御资质 = 0
			}
			local 地图名称 = {
				{
					"体质",
					5,
					"东海湾"
				},
				{
					"最大气血",
					40,
					"江南野外"
				},
				{
					"攻击资质",
					10,
					"大雁塔"
				},
				{
					"魔力",
					5,
					"大唐国境"
				},
				{
					"力量",
					5,
					"大唐境外"
				},
				{
					"最大气血",
					40,
					"魔王寨"
				},
				{
					"速度",
					5,
					"普陀山"
				},
				{
					"最大魔法",
					40,
					"盘丝岭"
				},
				{
					"伤害",
					5,
					"狮驼岭"
				},
				{
					"防御",
					5,
					"西牛贺州"
				},
				{
					"速度",
					5,
					"花果山"
				},
				{
					"耐力",
					5,
					"海底迷宫"
				},
				{
					"防御资质",
					10,
					"地狱迷宫"
				},
				{
					"敏捷",
					5,
					"北俱芦洲"
				},
				{
					"体力资质",
					10,
					"龙窟"
				},
				{
					"法力资质",
					10,
					"凤巢"
				},
				{
					"速度",
					5,
					"无名鬼城"
				},
				{
					"灵力",
					5,
					"小西天"
				},
				{
					"成长",
					0.05,
					"女娲神迹"
				},
				{
					"速度资质",
					10,
					"小雷音寺"
				},
				{
					"攻击资质",
					5,
					"蓬莱仙岛"
				},
				{
					"攻击资质",
					5,
					"月宫"
				},
				{
					"攻击资质",
					5,
					"蟠桃园"
				},
				{
					"攻击资质",
					5,
					"墨家禁地"
				},
				{
					"攻击资质",
					5,
					"解阳山"
				},
				{
					"攻击资质",
					5,
					"子母河底"
				},
				{
					"法力资质",
					5,
					"麒麟山"
				},
				{
					"法力资质",
					5,
					"碗子山"
				},
				{
					"法力资质",
					5,
					"波月洞"
				},
				{
					"法力资质",
					5,
					"柳林坡"
				},
				{
					"法力资质",
					5,
					"比丘国"
				},
				{
					"法力资质",
					5,
					"须弥东界"
				}
			}

			if 图鉴系统[self.数字id] ~= nil then
				for n = 1, 32 do
					if 图鉴系统[self.数字id][地图名称[n][3]].激活 == 101 then
						self.数据[编号].宠物图鉴属性[地图名称[n][1]] = self.数据[编号].宠物图鉴属性[地图名称[n][1]] + 地图名称[n][2]
					elseif 图鉴系统[self.数字id][地图名称[n][3]].激活 == 102 then
						self.数据[编号].宠物图鉴属性[地图名称[n][1]] = self.数据[编号].宠物图鉴属性[地图名称[n][1]] + 地图名称[n][2] * 2
					elseif 图鉴系统[self.数字id][地图名称[n][3]].激活 == 103 then
						self.数据[编号].宠物图鉴属性[地图名称[n][1]] = self.数据[编号].宠物图鉴属性[地图名称[n][1]] + 地图名称[n][2] * 3
					end
				end
			end

			local 全激活 = 0

			if 图鉴系统[self.数字id].全激活 ~= true then
				for i, v in pairs(图鉴系统[self.数字id]) do
					if 图鉴系统[self.数字id][i].激活 == 103 then
						全激活 = 全激活 + 1
					end
				end
			else
				全激活 = #地图名称 + 0
			end

			if 全激活 >= #地图名称 then
				图鉴系统[self.数字id].全激活 = true

				if self.数据[编号].图鉴全激活 == nil then
					self.数据[编号].图鉴全激活 = true

					for y, v in pairs(self.数据[编号].宠物图鉴属性) do
						self.数据[编号].宠物图鉴属性[y] = self.数据[编号].宠物图鉴属性[y] + self.数据[编号].宠物图鉴属性[y] / 3
					end

					for t, v in pairs(发送数据) do
						发送数据[t] = 发送数据[t] + self.数据[编号].宠物图鉴属性[t] / 3
					end
				end
			end

			玩家数据[self.数字id].角色.数据.刷新时间 = os.time()

			self:刷新信息(编号, "5628", 发送数据)
		end
	end
end

function 召唤兽处理类:刷新信息(编号, 是否, 图鉴, id)
	if self.数据 == nil then
		self.数据 = 玩家数据[id].召唤兽.数据
	end

	if 编号 == nil or self.数据[编号] == nil then
		return
	end

	if self.数据[编号].宠物图鉴属性 == nil or 判断是否为空表(self.数据[编号].宠物图鉴属性) or self.数据[编号].宠物图鉴属性.最大气血1 ~= nil then
		self.数据[编号].宠物图鉴属性 = {
			躲闪资质 = 0,
			体质 = 0,
			体力资质 = 0,
			速度 = 0,
			力量 = 0,
			防御 = 0,
			成长 = 0,
			灵力 = 0,
			速度资质 = 0,
			法力资质 = 0,
			魔力 = 0,
			最大魔法 = 0,
			敏捷 = 0,
			最大气血 = 0,
			耐力 = 0,
			伤害 = 0,
			攻击资质 = 0,
			防御资质 = 0
		}
	end

	图鉴 = self.数据[编号].宠物图鉴属性

	if 是否 == "5628" or 图鉴 ~= nil then
		self.数据[编号].攻击资质 = self.数据[编号].攻击资质 + qz1(图鉴.攻击资质)
		self.数据[编号].体力资质 = self.数据[编号].体力资质 + qz1(图鉴.体力资质)
		self.数据[编号].防御资质 = self.数据[编号].防御资质 + qz1(图鉴.防御资质)
		self.数据[编号].法力资质 = self.数据[编号].法力资质 + qz1(图鉴.法力资质)
		self.数据[编号].速度资质 = self.数据[编号].速度资质 + qz1(图鉴.速度资质)
		self.数据[编号].躲闪资质 = self.数据[编号].躲闪资质 + qz1(图鉴.躲闪资质)
		self.数据[编号].成长 = self.数据[编号].成长 + qz1(图鉴.成长 * 1000) / 1000
	end

	if self.数据[编号].体质 == nil or self.数据[编号].魔力 == nil or self.数据[编号].耐力 == nil or self.数据[编号].力量 == nil or self.数据[编号].敏捷 == nil then
		常规提示(self.数字id, "你的召唤兽#R" .. self.数据[编号].名称 .. "#Y数据出错、被系统#R自动删除#Y！")

		self.数据[编号] = nil

		重置统御(self.数字id)
		常规提示(self.数字id, "你的召唤兽和坐骑统御#R已重置#Y！")

		return 编号
	end

	计算体质 = self.数据[编号].体质 + (self.数据[编号].装备属性.体质 or 0) + (self.数据[编号].进阶属性.体质 or 0) + (self.数据[编号].统御属性.体质 or 0) + (self.数据[编号].宠物图鉴属性.体质 or 0)
	计算魔力 = self.数据[编号].魔力 + (self.数据[编号].装备属性.魔力 or 0) + (self.数据[编号].进阶属性.魔力 or 0) + (self.数据[编号].统御属性.魔力 or 0) + (self.数据[编号].宠物图鉴属性.魔力 or 0)
	计算力量 = self.数据[编号].力量 + (self.数据[编号].装备属性.力量 or 0) + (self.数据[编号].进阶属性.力量 or 0) + (self.数据[编号].统御属性.力量 or 0) + (self.数据[编号].宠物图鉴属性.力量 or 0)
	计算耐力 = self.数据[编号].耐力 + (self.数据[编号].装备属性.耐力 or 0) + (self.数据[编号].进阶属性.耐力 or 0) + (self.数据[编号].统御属性.耐力 or 0) + (self.数据[编号].宠物图鉴属性.耐力 or 0)
	计算敏捷 = self.数据[编号].敏捷 + (self.数据[编号].装备属性.敏捷 or 0) + (self.数据[编号].进阶属性.敏捷 or 0) + (self.数据[编号].统御属性.敏捷 or 0) + (self.数据[编号].宠物图鉴属性.敏捷 or 0)
	self.数据[编号].计算体质 = 计算体质 + 0
	self.数据[编号].计算魔力 = 计算魔力 + 0
	self.数据[编号].计算力量 = 计算力量 + 0
	self.数据[编号].计算耐力 = 计算耐力 + 0
	self.数据[编号].计算敏捷 = 计算敏捷 + 0

	if self.数据[编号].饰品 ~= nil then
		self.数据[编号].饰品体资 = math.floor(self.数据[编号].体力资质 * 0.1)
		self.数据[编号].饰品攻资 = math.floor(self.数据[编号].攻击资质 * 0.1)
		self.数据[编号].饰品法资 = math.floor(self.数据[编号].法力资质 * 0.1)
		self.数据[编号].饰品防资 = math.floor(self.数据[编号].防御资质 * 0.1)
		self.数据[编号].饰品速资 = math.floor(self.数据[编号].速度资质 * 0.1)
		self.数据[编号].饰品躲资 = math.floor(self.数据[编号].躲闪资质 * 0.1)
		self.数据[编号].体力资质 = self.数据[编号].体力资质 + self.数据[编号].饰品体资
		self.数据[编号].攻击资质 = self.数据[编号].攻击资质 + self.数据[编号].饰品攻资
		self.数据[编号].法力资质 = self.数据[编号].法力资质 + self.数据[编号].饰品法资
		self.数据[编号].防御资质 = self.数据[编号].防御资质 + self.数据[编号].饰品防资
		self.数据[编号].速度资质 = self.数据[编号].速度资质 + self.数据[编号].饰品速资
		self.数据[编号].躲闪资质 = self.数据[编号].躲闪资质 + self.数据[编号].饰品躲资
	end

	if 召唤兽资质涉及成长 == true then
		self.数据[编号].最大气血 = qz1(self.数据[编号].等级 * self.数据[编号].体力资质 / 1000 + 计算体质 * self.数据[编号].成长 * 6 + self.数据[编号].装备属性.气血 + self.数据[编号].宠物图鉴属性.最大气血)
		self.数据[编号].最大魔法 = qz1(self.数据[编号].等级 * self.数据[编号].法力资质 / 500 + 计算魔力 * self.数据[编号].成长 * 3 + self.数据[编号].装备属性.魔法 + self.数据[编号].宠物图鉴属性.最大魔法)
		self.数据[编号].伤害 = qz1(self.数据[编号].等级 * self.数据[编号].攻击资质 * (self.数据[编号].成长 * 1.3 + 1.9) / 1000 + 计算力量 * self.数据[编号].成长 + self.数据[编号].装备属性.命中 / 3 + self.数据[编号].装备属性.伤害 + self.数据[编号].宠物图鉴属性.伤害)
		self.数据[编号].防御 = qz1(self.数据[编号].等级 * self.数据[编号].防御资质 * (self.数据[编号].成长 * 0.87 + 1.23) / 1000 + 计算耐力 * self.数据[编号].成长 * 1.33 + self.数据[编号].装备属性.防御 + self.数据[编号].宠物图鉴属性.防御)
		self.数据[编号].速度 = qz1(self.数据[编号].速度资质 * 计算敏捷 / 1000 * self.数据[编号].成长) + self.数据[编号].装备属性.速度 + self.数据[编号].宠物图鉴属性.速度
		self.数据[编号].灵力 = qz1(self.数据[编号].等级 * self.数据[编号].法力资质 * 0.0003 * self.数据[编号].成长 + self.数据[编号].等级 * 0.5 + 计算魔力 * 0.7 * self.数据[编号].成长 + 计算力量 * 0.4 + 计算体质 * 0.3 + 计算耐力 * 0.2) + self.数据[编号].装备属性.灵力 + self.数据[编号].宠物图鉴属性.灵力
		self.数据[编号].躲避 = qz1(self.数据[编号].躲闪资质 * 计算敏捷 / 1000 * self.数据[编号].成长) + self.数据[编号].装备属性.躲避
		self.数据[编号].法伤 = self.数据[编号].灵力
		self.数据[编号].法防 = self.数据[编号].灵力
	else
		self.数据[编号].最大气血 = qz1(self.数据[编号].等级 * self.数据[编号].体力资质 / 1000 + 计算体质 * self.数据[编号].成长 * 6 + self.数据[编号].装备属性.气血 + self.数据[编号].宠物图鉴属性.最大气血)
		self.数据[编号].最大魔法 = qz1(self.数据[编号].等级 * self.数据[编号].法力资质 / 500 + 计算魔力 * self.数据[编号].成长 * 3 + self.数据[编号].装备属性.魔法 + self.数据[编号].宠物图鉴属性.最大魔法)
		self.数据[编号].伤害 = qz1(self.数据[编号].等级 * self.数据[编号].攻击资质 * (self.数据[编号].成长 * 1.3 + 1.9) / 1000 + 计算力量 * self.数据[编号].成长 + self.数据[编号].装备属性.命中 / 3 + self.数据[编号].装备属性.伤害 + self.数据[编号].宠物图鉴属性.伤害)
		self.数据[编号].防御 = qz1(self.数据[编号].等级 * self.数据[编号].防御资质 * (self.数据[编号].成长 * 0.87 + 1.23) / 1000 + 计算耐力 * self.数据[编号].成长 * 1.33 + self.数据[编号].装备属性.防御 + self.数据[编号].宠物图鉴属性.防御)
		self.数据[编号].速度 = qz1(self.数据[编号].速度资质 * 计算敏捷 / 1000) + self.数据[编号].装备属性.速度 + self.数据[编号].宠物图鉴属性.速度
		self.数据[编号].灵力 = qz1(self.数据[编号].等级 * self.数据[编号].法力资质 * 0.0003 + self.数据[编号].等级 * 0.5 + 计算魔力 * 0.7 + 计算力量 * 0.4 + 计算体质 * 0.3 + 计算耐力 * 0.2) + self.数据[编号].装备属性.灵力 + self.数据[编号].宠物图鉴属性.灵力
		self.数据[编号].法伤 = qz1(self.数据[编号].等级 * self.数据[编号].法力资质 * 0.0003 * self.数据[编号].成长 + self.数据[编号].等级 * 0.5 + 计算魔力 * 0.7 * self.数据[编号].成长 + 计算力量 * 0.4 + 计算体质 * 0.3 + 计算耐力 * 0.2) + self.数据[编号].装备属性.灵力 + self.数据[编号].宠物图鉴属性.灵力
		self.数据[编号].躲避 = qz1(self.数据[编号].躲闪资质 * 计算敏捷 / 1000) + self.数据[编号].装备属性.躲避
		self.数据[编号].法防 = self.数据[编号].灵力
	end

	if self.数据[编号].等级 < 召唤兽最高等级 then
		self.数据[编号].最大经验 = 统一取经验(2, self.数据[编号].等级)
	end

	local 面板技能 = {}

	if self:取指定技能(编号, "高级迟钝") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 0.5)

		加入列表索引(面板技能, "高级迟钝")
	elseif self:取指定技能(编号, "迟钝") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 0.8)

		加入列表索引(面板技能, "迟钝")
	end

	if self:取指定技能(编号, "超级敏捷") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 1.2)

		加入列表索引(面板技能, "超级敏捷")
	elseif self:取指定技能(编号, "高级敏捷") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 1.2)

		加入列表索引(面板技能, "高级敏捷")
	elseif self:取指定技能(编号, "敏捷") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 1.1)

		加入列表索引(面板技能, "敏捷")
	end

	if self:取指定技能(编号, "溜之大吉") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 1.2)

		加入列表索引(面板技能, "溜之大吉")
	end

	if self:取指定技能(编号, "逍遥游") then
		self.数据[编号].速度 = math.ceil(self.数据[编号].速度 * 1.2)

		加入列表索引(面板技能, "逍遥游")
	end

	if self:取指定技能(编号, "超级精神集中") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.1)

		加入列表索引(面板技能, "超级精神集中")
	elseif self:取指定技能(编号, "高级精神集中") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.1)

		加入列表索引(面板技能, "高级精神集中")
	end

	if self:取指定技能(编号, "神出鬼没") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.1)

		加入列表索引(面板技能, "神出鬼没")
	end

	if self:取指定技能(编号, "超级感知") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.1)

		加入列表索引(面板技能, "超级感知")
	elseif self:取指定技能(编号, "高级感知") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.1)

		加入列表索引(面板技能, "高级感知")
	elseif self:取指定技能(编号, "感知") then
		self.数据[编号].躲避 = qz(self.数据[编号].躲避 * 1.05)

		加入列表索引(面板技能, "感知")
	end

	if self:取指定技能(编号, "超级幸运") then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.15)

		加入列表索引(面板技能, "超级幸运")
	elseif self:取指定技能(编号, "高级幸运") then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.1)

		加入列表索引(面板技能, "高级幸运")
	elseif self:取指定技能(编号, "幸运") then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.05)

		加入列表索引(面板技能, "幸运")
	end

	if self:取指定技能(编号, "高级健壮") then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.25)

		加入列表索引(面板技能, "高级健壮")
	elseif self:取指定技能(编号, "健壮") then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.15)

		加入列表索引(面板技能, "健壮")
	end

	if self:取指定技能(编号, "欣欣向荣") and self.数据[编号].五行 == "木" then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.4)

		加入列表索引(面板技能, "欣欣向荣")
	elseif self:取指定技能(编号, "茁壮") and self.数据[编号].五行 == "木" then
		self.数据[编号].最大气血 = qz(self.数据[编号].最大气血 * 1.25)

		加入列表索引(面板技能, "茁壮")
	end

	if self:取指定技能(编号, "净台妙谛") then
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + 计算体质 * self.数据[编号].成长 * 2

		加入列表索引(面板技能, "净台妙谛")
	end

	if self:取指定技能(编号, "高级强壮") then
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + self.数据[编号].等级 * 4 + 100

		加入列表索引(面板技能, "高级强壮")
	end

	if self:取指定技能(编号, "张弛有道") then
		self.数据[编号].法伤 = self.数据[编号].法伤 + 100
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + 380

		加入列表索引(面板技能, "张弛有道")
	end

	if self:取指定技能(编号, "开门见山") then
		self.数据[编号].伤害 = self.数据[编号].伤害 + 100
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + 380

		加入列表索引(面板技能, "开门见山")
	end

	if self:取指定技能(编号, "千锤百炼") then
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + 540

		加入列表索引(面板技能, "千锤百炼")
	end

	if self:取指定技能(编号, "赴汤蹈火") then
		self.数据[编号].最大气血 = self.数据[编号].最大气血 + 540

		加入列表索引(面板技能, "赴汤蹈火")
	end

	if self:取指定技能(编号, "灵山禅语") then
		self.数据[编号].最大魔法 = qz1(self.数据[编号].最大魔法 - 计算魔力 * self.数据[编号].成长 * 3 * 0.5)
		self.数据[编号].法防 = qz1(self.数据[编号].法防 + 计算魔力 * self.数据[编号].成长)
		self.数据[编号].法伤 = qz1(self.数据[编号].法伤 - 计算魔力 * 0.7 * self.数据[编号].成长)

		加入列表索引(面板技能, "灵山禅语")
	end

	if self:取指定技能(编号, "须弥真言") then
		self.数据[编号].法伤 = self.数据[编号].法伤 + qz1(计算魔力 * 0.4)

		加入列表索引(面板技能, "须弥真言")
	end

	if self:取指定技能(编号, "圣婴大王") then
		self.数据[编号].法伤 = self.数据[编号].法伤 + qz1(计算魔力 * 0.5)

		加入列表索引(面板技能, "圣婴大王")
	end

	if self:取指定技能(编号, "诸天正法") then
		self.数据[编号].伤害 = self.数据[编号].伤害 + qz1(计算力量 * self.数据[编号].成长 * 0.2)
		self.数据[编号].防御 = self.数据[编号].防御 - qz1(计算力量 * 0.2)

		加入列表索引(面板技能, "诸天正法")
	end

	if self:取指定技能(编号, "超级强力") then
		self.数据[编号].伤害 = self.数据[编号].伤害 + qz1(self.数据[编号].等级 * 0.7)

		加入列表索引(面板技能, "超级强力")
	elseif self:取指定技能(编号, "高级强力") then
		self.数据[编号].伤害 = self.数据[编号].伤害 + qz1(self.数据[编号].等级 * 0.55)

		加入列表索引(面板技能, "高级强力")
	elseif self:取指定技能(编号, "强力") then
		self.数据[编号].伤害 = self.数据[编号].伤害 + qz1(self.数据[编号].等级 * 0.4)

		加入列表索引(面板技能, "强力")
	end

	if self:取指定技能(编号, "超级防御") then
		self.数据[编号].防御 = self.数据[编号].防御 + qz1(self.数据[编号].等级 * 0.8)

		加入列表索引(面板技能, "超级防御")
	elseif self:取指定技能(编号, "高级防御") then
		self.数据[编号].防御 = self.数据[编号].防御 + qz1(self.数据[编号].等级 * 0.8)

		加入列表索引(面板技能, "高级防御")
	elseif self:取指定技能(编号, "防御") then
		self.数据[编号].防御 = self.数据[编号].防御 + qz1(self.数据[编号].等级 * 0.6)

		加入列表索引(面板技能, "防御")
	end

	self.数据[编号].面板技能 = 面板技能

	if self.数据[编号].内丹 ~= nil then
		for i = 1, #self.数据[编号].内丹 do
			if self.数据[编号].内丹[i].技能 == "迅敏" then
				self.数据[编号].伤害 = self.数据[编号].伤害 + qz(self.数据[编号].等级 * 0.08 * self.数据[编号].内丹[i].等级)
				self.数据[编号].速度 = self.数据[编号].速度 + qz(self.数据[编号].等级 * 0.05 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "静岳" then
				self.数据[编号].灵力 = self.数据[编号].灵力 + qz(self.数据[编号].等级 * 0.04 * self.数据[编号].内丹[i].等级)
				self.数据[编号].法伤 = self.数据[编号].法伤 + qz(self.数据[编号].等级 * 0.04 * self.数据[编号].内丹[i].等级)
				self.数据[编号].法防 = self.数据[编号].法防 + qz(self.数据[编号].等级 * 0.04 * self.数据[编号].内丹[i].等级)
				self.数据[编号].最大气血 = self.数据[编号].最大气血 + qz(self.数据[编号].等级 * 0.4 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "矫健" then
				self.数据[编号].最大气血 = self.数据[编号].最大气血 + qz(self.数据[编号].等级 * 0.5 * self.数据[编号].内丹[i].等级)
				self.数据[编号].速度 = self.数据[编号].速度 + qz(self.数据[编号].等级 * 0.05 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "灵光" then
				self.数据[编号].灵力 = self.数据[编号].灵力 + qz(计算魔力 * 0.02 * self.数据[编号].内丹[i].等级)
				self.数据[编号].法伤 = self.数据[编号].法伤 + qz(计算魔力 * 0.02 * self.数据[编号].内丹[i].等级)
				self.数据[编号].法防 = self.数据[编号].法防 + qz(计算魔力 * 0.02 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "阴阳护" then
				self.数据[编号].最大魔法 = self.数据[编号].最大魔法 + qz(self.数据[编号].等级 * 0.5 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "凛冽气" then
				self.数据[编号].速度 = self.数据[编号].速度 + qz(self.数据[编号].等级 * 0.08 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "玄武躯" then
				self.数据[编号].最大气血 = self.数据[编号].最大气血 + qz(self.数据[编号].等级 * 2 * self.数据[编号].内丹[i].等级)
			end

			if self.数据[编号].内丹[i].技能 == "龙胄铠" then
				self.数据[编号].防御 = self.数据[编号].防御 + qz(self.数据[编号].等级 * 0.5 * self.数据[编号].内丹[i].等级)
			end
		end
	end

	if self.数据[编号].气血 == nil then
		self.数据[编号].气血 = self.数据[编号].最大气血
	end

	if self.数据[编号].魔法 == nil then
		self.数据[编号].魔法 = self.数据[编号].最大魔法
	end

	if 是否 == "1" then
		self.数据[编号].气血 = self.数据[编号].最大气血
		self.数据[编号].魔法 = self.数据[编号].最大魔法
	end

	if self.数据[编号].最大气血 < self.数据[编号].气血 then
		self.数据[编号].气血 = self.数据[编号].最大气血
	end

	if self.数据[编号].最大魔法 < self.数据[编号].魔法 then
		self.数据[编号].魔法 = self.数据[编号].最大魔法
	end

	if self.数据[编号].饰品 ~= nil then
		self.数据[编号].体力资质 = self.数据[编号].体力资质 - self.数据[编号].饰品体资
		self.数据[编号].攻击资质 = self.数据[编号].攻击资质 - self.数据[编号].饰品攻资
		self.数据[编号].法力资质 = self.数据[编号].法力资质 - self.数据[编号].饰品法资
		self.数据[编号].防御资质 = self.数据[编号].防御资质 - self.数据[编号].饰品防资
		self.数据[编号].速度资质 = self.数据[编号].速度资质 - self.数据[编号].饰品速资
		self.数据[编号].躲闪资质 = self.数据[编号].躲闪资质 - self.数据[编号].饰品躲资
	end

	if 是否 == "5628" or 图鉴 ~= nil then
		self.数据[编号].攻击资质 = self.数据[编号].攻击资质 - qz1(图鉴.攻击资质)
		self.数据[编号].体力资质 = self.数据[编号].体力资质 - qz1(图鉴.体力资质)
		self.数据[编号].防御资质 = self.数据[编号].防御资质 - qz1(图鉴.防御资质)
		self.数据[编号].法力资质 = self.数据[编号].法力资质 - qz1(图鉴.法力资质)
		self.数据[编号].速度资质 = self.数据[编号].速度资质 - qz1(图鉴.速度资质)
		self.数据[编号].躲闪资质 = self.数据[编号].躲闪资质 - qz1(图鉴.躲闪资质)
		self.数据[编号].成长 = self.数据[编号].成长 - qz1(图鉴.成长 * 1000) / 1000
	end
end

function 召唤兽处理类:刷新套装效果(编号)
	self.数据[编号].护符附带技能 = {}

	if self.数据[编号].套装 == nil then
		self.数据[编号].套装 = {}
	end

	if self.数据[编号].套装.附加状态 == nil then
		self.数据[编号].套装.附加状态 = {}
	end

	if self.数据[编号].套装.追加法术 == nil then
		self.数据[编号].套装.追加法术 = {}
	end

	self.数据[编号].套装技能 = {}

	for k, v in pairs(self.数据[编号].套装.附加状态) do
		if bb套装生效件数 <= v then
			self.数据[编号].套装技能[k] = 1
		end
	end

	if 追加法术是否添加主动技能 then
		for k, v in pairs(self.数据[编号].套装.追加法术) do
			if bb套装生效件数 <= v then
				self.数据[编号].套装技能[k] = 1
			end
		end
	end

	local 套装技能 = {}

	for k, v in pairs(self.数据[编号].套装技能) do
		套装技能[#套装技能 + 1] = k
	end

	self.数据[编号].护符附带技能 = 列表2加入到列表1(self.数据[编号].护符技能 or {}, 套装技能)

	删除重复(self.数据[编号].护符附带技能)
	self:刷新信息(编号)
end

function 召唤兽处理类:穿戴装备(装备, 格子, 编号)
	for i = 1, #装备基础属性列表 do
		if 装备[装备基础属性列表[i]] ~= nil then
			self.数据[编号].装备属性[装备基础属性列表[i]] = (self.数据[编号].装备属性[装备基础属性列表[i]] or 0) + 装备[装备基础属性列表[i]]
		end
	end

	if 装备.超级五行 ~= nil and 装备.超级五行.类型 ~= nil then
		self.数据[编号].装备属性[装备.超级五行.属性] = (self.数据[编号].装备属性[装备.超级五行.属性] or 0) + (装备.超级五行.数值 or 0)
	end

	self.数据[编号].护符附带技能 = {}

	if 装备.附带技能 ~= nil and #装备.附带技能 > 0 then
		self.数据[编号].护符技能 = {}

		for i = 1, #装备.附带技能 do
			self.数据[编号].护符技能[i] = 装备.附带技能[i]
		end
	end

	if 装备.次数 ~= nil then
		装备.次数 = 装备.次数 - 1
	end

	self.数据[编号].套装技能 = {}

	if self.数据[编号].套装 == nil then
		self.数据[编号].套装 = {}
	end

	if self.数据[编号].套装.附加状态 == nil then
		self.数据[编号].套装.附加状态 = {}
	end

	if self.数据[编号].套装.追加法术 == nil then
		self.数据[编号].套装.追加法术 = {}
	end

	self.数据[编号].装备[格子] = 装备

	if 装备.套装效果 ~= nil then
		if #self.数据[编号].套装 > 0 then
			for i = 1, #self.数据[编号].套装 do
				self.数据[编号].套装[i] = nil
			end
		end

		if 装备.套装效果[1] == "附加状态" then
			self.数据[编号].套装.附加状态[装备.套装效果[2]] = (self.数据[编号].套装.附加状态[装备.套装效果[2]] or 0) + 1
		elseif 装备.套装效果[1] == "追加法术" then
			self.数据[编号].套装.追加法术[装备.套装效果[2]] = (self.数据[编号].套装.追加法术[装备.套装效果[2]] or 0) + 1
		end
	end

	for k, v in pairs(self.数据[编号].套装.附加状态) do
		if bb套装生效件数 <= v then
			self.数据[编号].套装技能[k] = 1
		end
	end

	if 追加法术是否添加主动技能 then
		for k, v in pairs(self.数据[编号].套装.追加法术) do
			if bb套装生效件数 <= v then
				self.数据[编号].套装技能[k] = 1
			end
		end
	end

	local 套装技能 = {}

	for k, v in pairs(self.数据[编号].套装技能) do
		套装技能[#套装技能 + 1] = k
	end

	self.数据[编号].护符附带技能 = 列表2加入到列表1(self.数据[编号].护符技能 or {}, 套装技能)

	删除重复(self.数据[编号].护符附带技能)
	self:刷新信息(编号)
end

function 召唤兽处理类:卸下装备(装备, 格子, 编号, 不刷新)
	if self.数据[编号].无耐久减属性 == nil and 装备.耐久 ~= nil and 装备.耐久 <= 0 then
		return
	end

	for i = 1, #装备基础属性列表 do
		if 装备[装备基础属性列表[i]] ~= nil then
			self.数据[编号].装备属性[装备基础属性列表[i]] = math.max((self.数据[编号].装备属性[装备基础属性列表[i]] or 0) - 装备[装备基础属性列表[i]], 0)
		end
	end

	if 装备.超级五行 ~= nil and 装备.超级五行.类型 ~= nil then
		self.数据[编号].装备属性[装备.超级五行.属性] = math.max((self.数据[编号].装备属性[装备.超级五行.属性] or 0) - (装备.超级五行.数值 or 0), 0)
	end

	self.数据[编号].护符附带技能 = {}

	if 装备.附带技能 ~= nil and #装备.附带技能 > 0 then
		self.数据[编号].护符技能 = {}
	end

	if self.数据[编号].套装 == nil then
		self.数据[编号].套装 = {}
	end

	if self.数据[编号].套装.附加状态 == nil then
		self.数据[编号].套装.附加状态 = {}
	end

	if self.数据[编号].套装.追加法术 == nil then
		self.数据[编号].套装.追加法术 = {}
	end

	self.数据[编号].套装技能 = {}

	if 装备.套装效果 ~= nil then
		if #self.数据[编号].套装 > 0 then
			for i = 1, #self.数据[编号].套装 do
				self.数据[编号].套装[i] = nil
			end
		end

		if 装备.套装效果[1] == "附加状态" then
			self.数据[编号].套装.附加状态[装备.套装效果[2]] = math.max((self.数据[编号].套装.附加状态[装备.套装效果[2]] or 0) - 1, 0)
		elseif 装备.套装效果[1] == "追加法术" then
			self.数据[编号].套装.追加法术[装备.套装效果[2]] = math.max((self.数据[编号].套装.追加法术[装备.套装效果[2]] or 0) - 1, 0)
		end
	end

	for k, v in pairs(self.数据[编号].套装.附加状态) do
		if v < bb套装生效件数 then
			self.数据[编号].套装技能[k] = nil
			self.数据[编号].套装.附加状态[k] = nil
		end
	end

	if 追加法术是否添加主动技能 then
		for k, v in pairs(self.数据[编号].套装.追加法术) do
			if v < bb套装生效件数 then
				self.数据[编号].套装技能[k] = nil
				self.数据[编号].套装.追加法术[k] = nil
			end
		end
	end

	local 套装技能 = {}

	for k, v in pairs(self.数据[编号].套装技能) do
		套装技能[#套装技能 + 1] = k
	end

	self.数据[编号].护符附带技能 = 列表2加入到列表1(self.数据[编号].护符技能 or {}, 套装技能)

	删除重复(self.数据[编号].护符附带技能)

	if 不刷新 == nil then
		self:刷新信息(编号)
	end
end

function 召唤兽处理类:重置等级(等级, 编号)
	self.数据[编号].等级 = 等级

	self:洗点处理1(编号)
end

function 召唤兽处理类:取指定技能(编号, 名称)
	local 技能列表 = nil

	if self.数据[编号].护符附带技能 ~= nil and not 判断是否为空表(self.数据[编号].护符附带技能) then
		技能列表 = 列表2加入到列表1(self.数据[编号].技能, self.数据[编号].护符附带技能)
	else
		技能列表 = self.数据[编号].技能
	end

	for n = 1, #技能列表 do
		if 技能列表[n] == 名称 then
			return true
		end
	end

	return false
end

function 召唤兽处理类:取存档数据(编号)
	if 编号 ~= nil then
		return self.数据[编号]
	end

	return self.数据
end

function 召唤兽处理类:获取指定数据(编号)
	return table.tostring(self.数据[编号])
end

function 召唤兽处理类:解除统御助战(连接id, id, 临时编号, 不放生)
	local 排除 = 0

	if self.数据[临时编号] ~= nil and self.数据[临时编号].统御 ~= nil and 玩家数据[id].角色.数据.坐骑列表[self.数据[临时编号].统御] ~= nil then
		排除 = self.数据[临时编号].统御 + 0
		local 坐骑数据 = 玩家数据[id].角色.数据.坐骑列表[self.数据[临时编号].统御]
		local aa = 0

		for i = 1, #坐骑数据.统御召唤兽 do
			if 坐骑数据.统御召唤兽[i] == 临时编号 then
				aa = i + 0
			elseif 临时编号 < 坐骑数据.统御召唤兽[i] then
				坐骑数据.统御召唤兽[i] = 坐骑数据.统御召唤兽[i] - 1
			end
		end

		if aa > 0 then
			table.remove(坐骑数据.统御召唤兽, aa)
		end
	end

	if 不放生 == nil then
		for n = 1, #玩家数据[id].角色.数据.坐骑列表 do
			if n ~= 排除 and 玩家数据[id].角色.数据.坐骑列表[n] ~= nil then
				local 坐骑数据 = 玩家数据[id].角色.数据.坐骑列表[n]

				for i = 1, #坐骑数据.统御召唤兽 do
					if 临时编号 < 坐骑数据.统御召唤兽[i] then
						坐骑数据.统御召唤兽[i] = 坐骑数据.统御召唤兽[i] - 1
					end
				end
			end
		end
	end

	if self.数据[临时编号] ~= nil then
		self.数据[临时编号].统御 = nil

		if self.数据[临时编号].助战参战 ~= nil and 玩家数据[id].助战.数据[self.数据[临时编号].助战参战] ~= nil then
			玩家数据[id].助战.数据[self.数据[临时编号].助战参战].宠物认证码 = nil
			self.数据[临时编号].助战参战 = nil
		end
	end
end

function 召唤兽处理类:放生处理(连接id, 序号, id, 点数)
	local 临时编号 = self:取编号(点数.序列)

	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	elseif self:是否有装备(临时编号) then
		常规提示(id, "请先卸下召唤兽所穿戴的装备")

		return
	else
		self:解除统御助战(连接id, id, 临时编号)
		table.remove(self.数据, 临时编号)

		if 点数.序列 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
			玩家数据[id].角色.数据.参战宝宝 = {}

			发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
		end

		常规提示(id, "你的这只召唤兽从你的眼前消失了~~")
		发送数据(连接id, 21, 临时编号)
	end
end

function 召唤兽处理类:出售处理(连接id, id, 编号)
	local 临时编号 = 编号

	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	elseif self:是否有装备(临时编号) then
		常规提示(id, "请先卸下召唤兽所穿戴的装备")

		return
	else
		self:解除统御助战(连接id, id, 临时编号)
		table.remove(self.数据, 临时编号)
	end
end

function 召唤兽处理类:删除处理(id, 临时编号)
	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	else
		if self.数据[临时编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
			玩家数据[id].角色.数据.参战宝宝 = {}

			发送数据(玩家数据[id].连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
		end

		table.remove(self.数据, 临时编号)
		发送数据(玩家数据[id].连接id, 45, 临时编号)
	end
end

function 召唤兽处理类:是否有装备(编号)
	if self.数据[编号] == nil then
		return false
	end

	for n = 1, 4 do
		if self.数据[编号].装备[n] ~= nil then
			return true
		end
	end

	return false
end

function 召唤兽处理类:是否有统御()
	for i = 1, #self.数据 do
		if self.数据[i].统御 ~= nil then
			return true
		end
	end

	return false
end

function 召唤兽处理类:耐久处理(id, 认证码, 耐久标准, 次数)
	if (次数 or 0) < 1 then
		return
	end

	local 编号 = self:取编号(认证码)

	if 编号 ~= 0 and self:是否有装备(编号) then
		local 永不磨损 = false

		for n = 1, 3 do
			if self.数据[编号].装备[n] ~= nil then
				永不磨损 = false

				if self.数据[编号].装备[n].耐久 == nil then
					self.数据[编号].装备[n].耐久 = 500
				end

				local 特效判断 = {}

				if self.数据[编号].装备[n].特效 ~= nil then
					特效判断 = 列表模式转换(self.数据[编号].装备[n].特效)
				end

				if 特效判断.永不磨损 ~= nil then
					永不磨损 = true
				end

				if 永不磨损 == false and self.数据[编号].装备[n] ~= nil and self.数据[编号].装备[n].耐久 > 0 then
					self.数据[编号].装备[n].耐久 = self.数据[编号].装备[n].耐久 - 耐久标准 * 次数

					if self.数据[编号].装备[n].耐久 <= 0 then
						self.数据[编号].无耐久减属性 = true
						self.数据[编号].装备[n].耐久 = 0

						self:卸下装备(self.数据[编号].装备[n], nil, 编号)
						发送数据(玩家数据[id].连接id, 7, "#y/你的#r/" .. self.数据[编号].装备[n].名称 .. "#y/因耐久度过低已无法使用")

						self.数据[编号].无耐久减属性 = nil
					end
				end
			end
		end
	end
end

function 召唤兽处理类:取气血差()
	local 数值 = 0

	for n = 1, #self.数据 do
		数值 = 数值 + self.数据[n].最大气血 - self.数据[n].气血
	end

	return 数值
end

function 召唤兽处理类:取魔法差()
	local 数值 = 0

	for n = 1, #self.数据 do
		数值 = 数值 + self.数据[n].最大魔法 - self.数据[n].魔法
	end

	return 数值
end

function 召唤兽处理类:取忠诚差()
	local 数值 = 0

	for n = 1, #self.数据 do
		数值 = 数值 + 100 - self.数据[n].忠诚
	end

	return 数值
end

去除转生属性 = function(召唤兽数据)
	if 召唤兽数据.转生 ~= nil and 召唤兽数据.转生 >= 1 then
		local 资质列表 = {
			"攻击资质",
			"防御资质",
			"体力资质",
			"法力资质",
			"速度资质",
			"躲闪资质",
			"成长"
		}
		local sx = 召唤兽数据.转生 + 0

		if sx ~= nil and sx >= 1 then
			for i = 1, #资质列表 do
				召唤兽数据[资质列表[i]] = 召唤兽数据[资质列表[i]] - 召唤兽转生加成[资质列表[i]] * sx
			end

			召唤兽数据.转生 = nil
		end

		if 召唤兽数据.种类 == "神兽" then
			local 转生技能 = {}

			for i = 1, sx do
				if 召唤兽转生技能[sx] ~= nil then
					if 召唤兽转生技能[sx][召唤兽数据.模型] ~= nil then
						转生技能[召唤兽转生技能[sx][召唤兽数据.模型]] = 1
					else
						转生技能[召唤兽转生技能[sx].通用] = 1
					end
				end
			end

			local 去除技能位置 = {}

			for i = 1, #召唤兽数据.技能 do
				if 转生技能[召唤兽数据.技能[i]] ~= nil then
					去除技能位置[#去除技能位置 + 1] = i
				end
			end

			for i = 1, #去除技能位置 do
				table.remove(召唤兽数据.技能, 去除技能位置[i] - (i - 1))
			end
		end
	end
end

function 召唤兽处理类:合宠处理(连接id, 序号, id, 内容)
	local 认证码1 = 内容.序列
	local 认证码2 = 内容.序列1
	local bb1, bb2 = nil
	local 绑定 = false

	for k, v in pairs(self.数据) do
		if v.认证码 == 认证码1 then
			bb1 = k
		end

		if v.认证码 == 认证码2 then
			bb2 = k
		end
	end

	if bb1 == nil or bb2 == nil then
		常规提示(id, "合宠宝宝数据错误，请重新打开界面进行合宠。")

		return
	end

	if self.数据[bb1] == nil or self.数据[bb2] == nil then
		return
	elseif self.数据[bb1].等级 < 合宠等级 or self.数据[bb2].等级 < 合宠等级 then
		常规提示(id, "要炼妖的召唤兽等级未达到" .. 合宠等级 .. "级!")

		return
	elseif self.数据[bb1].参战等级 == nil or self.数据[bb2].参战等级 == nil then
		常规提示(id, "你使用了换造型的召唤兽,无法炼妖")

		return
	elseif self.数据[bb1].最初模型 ~= nil or self.数据[bb2].最初模型 ~= nil then
		常规提示(id, "你使用了更换过模型的召唤兽,无法炼妖")

		return
	elseif self.数据[bb1].转生 ~= nil or self.数据[bb2].转生 ~= nil then
		常规提示(id, "你使用了转生过的召唤兽,无法炼妖")

		return
	elseif self.数据[bb1].种类 == "孩子" or self.数据[bb2].种类 == "孩子" or self.数据[bb2].种类 == "神兽" or self.数据[bb1].种类 == "神兽" or self.数据[bb1].神兽 or self.数据[bb2].神兽 then
		常规提示(id, "神兽或孩子无法进行此操作")

		return
	elseif self.数据[bb1].参战信息 ~= nil or self.数据[bb2].参战信息 ~= nil then
		常规提示(id, "召唤兽处于参战状态，请解除参战后再进行此操作")

		return
	elseif self:是否有装备(bb1) or self:是否有装备(bb2) then
		常规提示(id, "请先卸下召唤兽所穿戴的装备")

		return
	elseif self.数据[bb1].统御 ~= nil or self.数据[bb2].统御 ~= nil then
		常规提示(id, "召唤兽处于统御状态,请解除统御后再进行此操作")

		return
	elseif self.数据[bb1].法术认证 ~= nil or self.数据[bb2].法术认证 ~= nil then
		常规提示(id, "有法术认证的宝宝无法合宠")

		return
	else
		if self.数据[bb1].不可交易 or self.数据[bb2].不可交易 then
			绑定 = true
		end

		if self.数据[bb1].助战参战 ~= nil or 玩家数据[id].助战.数据[self.数据[bb1].助战参战] ~= nil then
			local 助战数据 = 玩家数据[id].助战.数据

			if self.数据[bb1].助战参战 ~= nil and 助战数据[self.数据[bb1].助战参战] ~= nil then
				助战数据[self.数据[bb1].助战参战].宠物认证码 = nil
			end

			if self.数据[bb2].助战参战 ~= nil and 助战数据[self.数据[bb2].助战参战] ~= nil then
				助战数据[self.数据[bb2].助战参战].宠物认证码 = nil
			end
		end

		随机类型 = self.数据[bb1].模型
		local 随机数值 = 取随机数(1, 1000)
		local 特殊合宠 = false
		local 特殊合宠1 = false
		local 特殊合宠类型 = {
			变异 = false,
			宝宝 = "宝宝"
		}

		if 随机数值 <= 5 then
			特殊合宠 = true

			if ygsj() <= 50 then
				随机类型 = "泡泡"
			else
				随机类型 = "大海龟"
			end
		elseif 随机数值 <= 30 then
			随机类型 = self.数据[bb2].模型
		else
			随机类型 = self.数据[bb1].模型
		end

		if not 特殊合宠 then
			local pd1 = 特殊宠物合成公式[self.数据[bb1].模型]

			if pd1 ~= nil then
				local pd2 = pd1[self.数据[bb2].模型]

				if pd2 ~= nil and ygsj() <= 特殊宠物合成概率 then
					随机类型 = pd2 .. ""
					特殊合宠1 = true

					if self.数据[bb1].种类 == self.数据[bb2].种类 == "变异" then
						特殊合宠类型.变异 = true
					elseif (self.数据[bb1].种类 == "变异" or self.数据[bb2].种类 == "变异") and (self.数据[bb1].种类 == "宝宝" or self.数据[bb2].种类 == "宝宝") then
						if ygsj() <= 50 then
							特殊合宠类型.变异 = true
						end
					elseif (self.数据[bb1].种类 == "野怪" or self.数据[bb2].种类 == "野怪") and ygsj() <= 50 then
						特殊合宠类型.宝宝 = "野怪"
					end
				end
			end
		end

		if 特殊合宠 or 特殊合宠1 then
			self:添加召唤兽(随机类型, 特殊合宠类型.宝宝, 特殊合宠类型.变异, false, 0, nil, bb1)
		else
			if (self.数据[bb1].种类 == "变异" or self.数据[bb2].种类 == "变异") and (self.数据[bb1].种类 == "宝宝" or self.数据[bb2].种类 == "宝宝") then
				if ygsj() <= 50 then
					self.数据[bb1].种类 = "变异"
				else
					self.数据[bb1].种类 = "宝宝"
				end
			elseif (self.数据[bb1].种类 == "野怪" or self.数据[bb2].种类 == "野怪") and (self.数据[bb1].种类 ~= "野怪" or self.数据[bb2].种类 ~= "野怪") then
				if ygsj() <= 50 then
					self.数据[bb1].种类 = "野怪"
				else
					self.数据[bb1].种类 = "宝宝"
				end
			end

			self.数据[bb1].模型 = 去模型进阶(随机类型)
			self.数据[bb1].进阶 = false

			for n = 1, #资质范围 do
				local 平均资质 = (self.数据[bb1][资质范围[n]] + self.数据[bb2][资质范围[n]]) / 2
				local 最低资质 = self.数据[bb1][资质范围[n]] + 20
				local 最高资质 = math.max(self.数据[bb1][资质范围[n]], self.数据[bb2][资质范围[n]])

				if 平均资质 < 最低资质 and (管理账号列表[玩家数据[id].账号] or 合宠保底资质开关) then
					平均资质 = 最低资质
				end

				local 封顶 = nil

				if n == 1 then
					封顶 = 资质上限.攻击资质
				elseif n == 4 then
					封顶 = 资质上限.法力资质
				elseif n == 3 then
					封顶 = 资质上限.体力资质
				else
					封顶 = 资质上限.防御资质
				end

				self.数据[bb1][资质范围[n]] = math.min(math.ceil(平均资质 * 资质梯度[math.ceil(取随机数(1, #资质梯度 * 10) / 10)]), 封顶)
			end

			local 平均成长 = (self.数据[bb1].成长 + self.数据[bb2].成长) / 2
			local 最低成长 = self.数据[bb1].成长 + 0.02
			local 最高成长 = math.max(self.数据[bb1].成长, self.数据[bb2].成长)

			if 平均成长 < 最低成长 and (管理账号列表[玩家数据[id].账号] or 合宠保底资质开关) then
				平均成长 = 最低成长
			end

			local cz = {}
			local cztd = 合宠成长最低梯度

			while cztd <= 合宠成长最高梯度 do
				cz[#cz + 1] = cztd + 0
				cztd = cztd + 合宠成长梯度
			end

			self.数据[bb1].成长 = 保留小数位数(平均成长 * cz[math.ceil(取随机数(1, #cz * 100) / 100)], 3)
			self.数据[bb1].成长 = math.min(self.数据[bb1].成长, 1.5)
			local 技能表 = {}

			for n = 1, #self.数据[bb2].技能 do
				技能表[#技能表 + 1] = self.数据[bb2].技能[n]
			end

			for n = 1, #self.数据[bb1].技能 do
				技能表[#技能表 + 1] = self.数据[bb1].技能[n]
			end

			for n = 1, #技能表 do
				技能表[n] = {
					名称 = 技能表[n],
					排列 = 取随机数(1, 10000)
				}
			end

			table.sort(技能表, function (a, b)
				return b.排列 < a.排列
			end)

			local 技能总数 = #技能表

			if 技能总数 < 24 or 合宠技能重复判断 then
				技能表 = 删除重复(技能表)
			end

			self.数据[bb1].技能 = {}
			local 技能表1 = {}

			if not 判断是否为空表(技能表) then
				local 保底 = 合宠保底技能数量

				if 技能总数 >= 20 then
					保底 = math.max(打书最大格子数 - 1, 合宠保底技能数量)
				end

				for n = 1, 技能总数 do
					local 成功几率 = math.max(100 - (#技能表1 + 0) * 合宠技能概率基数, 1)
					local SJ = ygsj(10000)

					if (n <= 保底 or SJ <= 成功几率 * 100) and #self.数据[bb1].技能 < 24 then
						技能表1[#技能表1 + 1] = 技能表[n].名称

						if 超级技能列表1[技能表1[#技能表1]] ~= nil then
							local aa = 超级技能列表1[超级技能列表1[技能表1[#技能表1]]]
							技能表1[#技能表1] = aa
						end
					end
				end

				if 技能总数 < 24 or 合宠技能重复判断 then
					技能表1 = 删除重复(技能表1)
				end

				if 合宠必带天生技能 then
					local 天生 = {}
					天生 = 取天生(随机类型)

					for i = 1, #天生 do
						local aa = true

						for w = 1, #技能表1 do
							if 技能表1[w] == 天生[i] then
								aa = false

								break
							end
						end

						if aa then
							table.insert(技能表1, 1, 天生[i])
						end
					end
				end

				self.数据[bb1].技能 = 列表打乱重组(技能表1)
			end

			local 等级总数 = math.floor((self.数据[bb1].等级 + self.数据[bb2].等级) / 2 * 0.5)

			if 等级总数 < 0 then
				等级总数 = 0
			end

			self.数据[bb1].等级 = 等级总数
			self.数据[bb1].当前经验 = 0
			self.数据[bb1].最大经验 = 统一取经验(2, self.数据[bb1].等级)
			local 生成类型 = ""
			local 随机点数 = ""
			local 种类 = "宝宝"

			if ygsj(1000) <= 金柳露变异概率 or self.数据[bb1].种类 == "神兽" or self.数据[bb1].种类 == "变异" then
				种类 = "变异"
			end

			self.数据[bb1].种类 = 种类
		end

		self.数据[bb1].饰品 = nil
		self.数据[bb1].饰品2 = nil
		self.数据[bb1].寿命 = 取随机数(5000, 10000)
		self.数据[bb1].自动指令 = nil
		self.数据[bb1].元宵 = {}
		self.数据[bb1].灵性 = 0
		self.数据[bb1].资质丸 = qz2(((self.数据[bb1].资质丸 or 0) + (self.数据[bb2].资质丸 or 0)) / 2)
		self.数据[bb1].孩子书 = math.max(self.数据[bb1].孩子书 or 0, self.数据[bb2].孩子书 or 0)
		self.数据[bb1].进阶 = false
		self.数据[bb1].仙露上限 = 7
		self.数据[bb1].特性 = "无"
		self.数据[bb1].特性几率 = 0
		self.数据[bb1].宠物图鉴属性 = nil
		self.数据[bb1].进阶属性 = {
			体质 = 0,
			力量 = 0,
			敏捷 = 0,
			耐力 = 0,
			魔力 = 0
		}
		self.数据[bb1].统御属性 = {
			体质 = 0,
			力量 = 0,
			敏捷 = 0,
			耐力 = 0,
			魔力 = 0
		}
		self.数据[bb1].五行 = 五行固定召唤兽[self.数据[bb1].模型] or 五行_[取随机数(1, 5)]

		if self.数据[bb1].种类 == "变异" then
			self.数据[bb1].名称 = "变异" .. self.数据[bb1].模型
			self.数据[bb1].变异 = true

			if 染色信息[self.数据[bb1].模型] ~= nil then
				self.数据[bb1].染色方案 = 染色信息[self.数据[bb1].模型].id
				self.数据[bb1].染色组 = {}

				for i = 1, 3 do
					if 染色信息[self.数据[bb1].模型].方案[i] ~= nil then
						self.数据[bb1].染色组[i] = 染色信息[self.数据[bb1].模型].方案[i]
					end
				end
			end
		else
			self.数据[bb1].名称 = self.数据[bb1].模型
		end

		self.数据[bb1].转生 = nil
		self.数据[bb1].洗点次数 = nil
		self.数据[bb1].超级技能数量 = 0
		local mx参战等级 = bbs(self.数据[bb1].模型)
		self.数据[bb1].参战等级 = math.max(mx参战等级[1] or 0, 0)

		if 绑定 then
			self.数据[bb1].不可交易 = true
		end

		if self.数据[bb1].种类 == "变异" then
			常规提示(id, "恭喜你合出了一只#R/变异" .. 随机类型)
		else
			常规提示(id, "恭喜你合出了一只#R/" .. 随机类型)
		end

		self:洗点处理1(bb1)
		self:解除统御助战(连接id, id, bb2)
		table.remove(self.数据, bb2)
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 26)
	end
end

function 召唤兽处理类:取野外等级差(地图等级, 玩家等级)
	local 等级 = math.abs(地图等级 - 玩家等级)

	if 等级 <= 5 then
		return 1
	elseif 等级 <= 10 then
		return 0.8
	elseif 等级 <= 20 then
		return 0.5
	else
		return 0.2
	end
end

召唤兽添加经验 = function(经验, id, 类型, 地图等级)
	if 服务端参数.BB经验模式 ~= 0 then
		for n = 1, #玩家数据[id].召唤兽.数据 do
			玩家数据[id].召唤兽:获得经验(玩家数据[id].召唤兽.数据[n].认证码, 经验, id, 类型, 地图等级)
		end
	else
		if 玩家数据[id].角色.数据.参战宝宝.认证码 ~= nil then
			玩家数据[id].召唤兽:获得经验(玩家数据[id].角色.数据.参战宝宝.认证码, 经验, id, 类型, 地图等级)
		end

		if 队伍数据[玩家数据[id].队伍] ~= nil and 队伍数据[玩家数据[id].队伍].成员数据[1] == id then
			for i = 2, 5 do
				if 队伍处理类:取是否助战(玩家数据[id].队伍, i) ~= 0 then
					local 助战编号 = 队伍处理类:取助战编号(玩家数据[id].队伍, i)
					local 助战bb认证码 = 玩家数据[id].助战.数据[助战编号].宠物认证码

					if 助战bb认证码 ~= nil then
						玩家数据[id].召唤兽:获得经验(助战bb认证码, 经验, id, 类型, 地图等级)
					end
				end
			end
		end
	end
end

function 召唤兽处理类:获得经验(认证码, 经验, id, 类型, 地图等级)
	local 编号 = self:取编号(认证码)

	if 编号 == 0 or self.数据[编号] == nil then
		return
	end

	local 高于等级 = 召唤兽经验高于等级

	if 玩家数据[id].角色.数据.剧情.飞升 == true and 玩家数据[id].角色.数据.飞升 == true then
		高于等级 = 召唤兽经验高于等级 + 飞升高于等级
	end

	if self.数据[编号].等级 >= 玩家数据[id].角色.数据.等级 + 高于等级 then
		return
	end

	if self.数据[编号].助战参战 == nil and self.数据[编号].参战信息 == nil and 服务端参数.BB经验模式 ~= 1 then
		return
	end

	local 临时经验 = 经验 * 1

	if 类型 == "野外" then
		local 临时参数 = self:取野外等级差(self.数据[编号].等级, 地图等级)
		临时经验 = 临时经验 * 临时参数

		if 经验 > 临时经验 then
			临时经验 = 经验
		end
	end

	local 基础倍率 = 服务端参数.经验获得率
	local 倍率 = 1

	if 类型 == "野外" or 类型 == "捉鬼" or 类型 == "官职" or 类型 == "封妖战斗" or 类型 == "种族" or 类型 == "门派闯关" or 类型 == "初出江湖" or 类型 == "悬赏任务" then
		if 玩家数据[id].角色:取任务(2) ~= 0 then
			倍率 = 倍率 + 1
		end

		if 玩家数据[id].角色:取任务(3) ~= 0 then
			倍率 = 倍率 + 1
		end
	end

	if 服务端参数.倍率模式 == 1 then
		if 玩家数据[id].角色:取任务(7756) ~= 0 then
			倍率 = 倍率 * 2
		end

		if 玩家数据[id].角色:取任务(7755) ~= 0 then
			倍率 = 倍率 * 3
		end

		if 玩家数据[id].角色:取任务(7757) ~= 0 then
			倍率 = 倍率 * 10
		end
	else
		if 玩家数据[id].角色:取任务(7756) ~= 0 then
			倍率 = 倍率 + 1
		end

		if 玩家数据[id].角色:取任务(7755) ~= 0 then
			倍率 = 倍率 + 2
		end

		if 玩家数据[id].角色:取任务(7757) ~= 0 then
			倍率 = 倍率 + 9
		end
	end

	临时经验 = math.floor(qz(临时经验 * 倍率 * 基础倍率))

	self:添加经验(玩家数据[id].连接id, id, 编号, 临时经验)
end

function 召唤兽处理类:升级(编号, id)
	if 召唤兽最高等级 <= self.数据[编号].等级 then
		self.数据[编号].当前经验 = 0

		return
	end

	local 神兽转生潜能点加成 = 0

	if self.数据[编号].种类 == "神兽" then
		if self.数据[编号].天生神兽 == true then
			神兽转生潜能点加成 = 神兽转生潜能点加成 + qz(服务端参数.宝宝升级潜能点 / 5)
		end

		if self.数据[编号].转生 ~= nil and self.数据[编号].转生 >= 2 then
			神兽转生潜能点加成 = 神兽转生潜能点加成 + qz(服务端参数.宝宝升级潜能点 / 5)
		end
	end

	self.数据[编号].等级 = self.数据[编号].等级 + 1
	self.数据[编号].体质 = self.数据[编号].体质 + 1
	self.数据[编号].魔力 = self.数据[编号].魔力 + 1
	self.数据[编号].力量 = self.数据[编号].力量 + 1
	self.数据[编号].耐力 = self.数据[编号].耐力 + 1
	self.数据[编号].敏捷 = self.数据[编号].敏捷 + 1
	self.数据[编号].潜力 = self.数据[编号].潜力 + 服务端参数.宝宝升级潜能点 + 神兽转生潜能点加成
	self.数据[编号].当前经验 = self.数据[编号].当前经验 - self.数据[编号].最大经验

	if self.数据[编号].自动加点 == true and self.数据[编号].加点方案 ~= nil and not 判断是否为空表(self.数据[编号].加点方案) and self.数据[编号].潜力 > 0 then
		local sx = {
			"体质",
			"魔力",
			"力量",
			"耐力",
			"敏捷"
		}
		local aa = 0

		for i = 1, self.数据[编号].潜力 do
			aa = self.数据[编号].加点方案[self.数据[编号].加点方案.当前]
			self.数据[编号][sx[aa]] = self.数据[编号][sx[aa]] + 1
			self.数据[编号].加点方案.当前 = self.数据[编号].加点方案.当前 + 1

			if self.数据[编号].加点方案.当前 > 5 then
				self.数据[编号].加点方案.当前 = 1
			end
		end

		self.数据[编号].潜力 = 0
	end

	self:刷新信息(编号, "1")
end

function 召唤兽处理类:降级(级数, 编号)
	self.数据[编号].等级 = self.数据[编号].等级 - 级数

	self:洗点处理1(编号)
end

function 召唤兽处理类:添加技能(名称, 编号)
	self.数据[编号].技能[#self.数据[编号].技能 + 1] = 名称
end

function 召唤兽处理类:替换技能(名称, 编号)
	self.数据[编号].技能[取随机数(1, #self.数据[编号].技能)] = 名称
end

function 召唤兽处理类:添加经验(连接id, id, 编号, 数额)
	if 召唤兽最高等级 <= self.数据[编号].等级 then
		return
	end

	local 高于等级 = 召唤兽经验高于等级

	if 玩家数据[id].角色.数据.剧情.飞升 == true and 玩家数据[id].角色.数据.飞升 == true then
		高于等级 = 召唤兽经验高于等级 + 飞升高于等级
	end

	if self.数据[编号].等级 >= 玩家数据[id].角色.数据.等级 + 高于等级 then
		return
	end

	if 召唤兽最高等级 <= self.数据[编号].等级 then
		return
	end

	local 实际数额 = 数额
	self.数据[编号].当前经验 = self.数据[编号].当前经验 + 实际数额

	发送数据(连接id, 27, {
		频道 = "xt",
		文本 = "#W/你的" .. self.数据[编号].名称 .. "#W/获得了" .. 数字转简(实际数额) .. "点经验"
	})

	if self.数据[编号].当前经验 == nil or self.数据[编号].最大经验 == nil then
		print("角色:" .. 玩家数据[id].角色.数据.名称 .. "召唤兽处理类:添加经验()接口处的数据异常")
	end

	while self.数据[编号].最大经验 <= self.数据[编号].当前经验 do
		if self.数据[编号].等级 >= 玩家数据[id].角色.数据.等级 + 高于等级 then
			break
		end

		self:升级(编号, id)
		发送数据(连接id, 27, {
			频道 = "xt",
			文本 = "#W/你的#R/" .. self.数据[编号].名称 .. "#W/等级提升到了#R/" .. self.数据[编号].等级 .. "#W/级"
		})
	end

	发送数据(连接id, 20, self:取存档数据(编号))

	if self.数据[编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
		玩家数据[id].角色.数据.参战宝宝 = {}
		玩家数据[id].角色.数据.参战宝宝 = table.loadstring(table.tostring(self:取存档数据(编号)))
		玩家数据[id].角色.数据.参战信息 = 1
		self.数据[编号].参战信息 = 1

		发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
	end
end

function 召唤兽处理类:加寿命处理(编号, 数额, 中毒, 连接id, id)
	self.数据[编号].寿命 = self.数据[编号].寿命 + 数额

	常规提示(id, "该召唤兽寿命增加了#R/" .. 数额 .. "点")

	if 中毒 ~= nil and 中毒 ~= 0 and ygsj() <= 中毒 then
		local 减少类型 = ""
		local 减少数量 = 0
		local 随机参数 = 取随机数(1, 6)

		if 随机参数 == 1 then
			减少类型 = "攻击资质"
			减少数量 = 取随机数(1, 5)
		elseif 随机参数 == 2 then
			减少类型 = "防御资质"
			减少数量 = 取随机数(1, 5)
		elseif 随机参数 == 3 then
			减少类型 = "体力资质"
			减少数量 = 取随机数(5, 20)
		elseif 随机参数 == 4 then
			减少类型 = "法力资质"
			减少数量 = 取随机数(3, 10)
		elseif 随机参数 == 5 then
			减少类型 = "躲闪资质"
			减少数量 = 取随机数(1, 5)
		elseif 随机参数 == 6 then
			减少类型 = "速度资质"
			减少数量 = 取随机数(1, 5)
		end

		self.数据[编号][减少类型] = self.数据[编号][减少类型] - 减少数量

		常规提示(id, "#W/你的召唤兽出现了中毒现象从而导致#G/" .. 减少类型 .. "#W/减少了#R/" .. 减少数量 .. "#W/点")
	end

	发送数据(连接id, 20, self:取存档数据(编号))
end

function 召唤兽处理类:加血处理(编号, 数额, 连接id, id)
	self.数据[编号].气血 = self.数据[编号].气血 + 数额

	if self.数据[编号].最大气血 < self.数据[编号].气血 then
		self.数据[编号].气血 = self.数据[编号].最大气血
	end

	发送数据(连接id, 20, self:取存档数据(编号))

	if self.数据[编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
		玩家数据[id].角色.数据.参战宝宝 = {}
		玩家数据[id].角色.数据.参战宝宝 = table.loadstring(table.tostring(self:取存档数据(编号)))
		玩家数据[id].角色.数据.参战信息 = 1
		self.数据[编号].参战信息 = 1

		发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
	end
end

function 召唤兽处理类:加蓝处理(编号, 数额, 连接id, id)
	self.数据[编号].魔法 = self.数据[编号].魔法 + 数额

	if self.数据[编号].最大魔法 < self.数据[编号].魔法 then
		self.数据[编号].魔法 = self.数据[编号].最大魔法
	end

	发送数据(连接id, 20, self:取存档数据(编号))

	if self.数据[编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
		玩家数据[id].角色.数据.参战宝宝 = {}
		玩家数据[id].角色.数据.参战宝宝 = table.loadstring(table.tostring(self:取存档数据(编号)))
		玩家数据[id].角色.数据.参战信息 = 1
		self.数据[编号].参战信息 = 1

		发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
	end
end

function 召唤兽处理类:召唤兽染色(连接id, 序号, id, 内容)
	local 编号 = self:取编号(内容.序列)

	if 扣除道具(id, "彩果", 20) ~= true then
		return
	end

	self.数据[编号].模型染色 = true

	if self.数据[编号].染色方案 == nil then
		self.数据[编号].染色方案 = 0
	end

	if self.数据[编号].染色组 == nil then
		self.数据[编号].染色组 = {}
	end

	self.数据[编号].染色方案 = 内容.序列1
	self.数据[编号].染色组 = {
		内容.序列2
	}

	print(tostring(内容.序列2) .. tostring(self.数据[编号].染色组[1]))

	self.数据[编号].染色组[2] = 内容.序列3

	print(tostring(内容.序列3) .. tostring(self.数据[编号].染色组[2]))

	self.数据[编号].染色组[3] = 内容.序列4

	print(tostring(内容.序列4) .. tostring(self.数据[编号].染色组[3]))
	常规提示(id, "#Y恭喜你，召唤兽染色成功！换个颜色换个心情")
	发送数据(连接id, 16, self.数据)
	发送数据(连接id, 20, self:取存档数据(编号))
end

function 召唤兽处理类:召唤兽饰品染色(连接id, 序号, id, 内容)
	local 编号 = self:取编号(内容.序列)
	local 编号 = self:取编号(内容.序列)

	if 扣除道具(id, "彩果", 20) ~= true then
		return
	end

	if self.数据[编号].饰品染色方案 == nil then
		self.数据[编号].饰品染色方案 = 0
	end

	if self.数据[编号].饰品染色组 == nil then
		self.数据[编号].饰品染色组 = {}
	end

	self.数据[编号].饰品染色方案 = 内容.序列1
	self.数据[编号].饰品染色组 = {
		内容.序列2,
		内容.序列3,
		内容.序列4
	}

	常规提示(id, "#Y恭喜你，召唤兽饰品染色成功！换个颜色换个心情")
	发送数据(连接id, 16, self.数据)
	道具刷新(id, 1)
	发送数据(连接id, 20, self:取存档数据(编号))
end

function 召唤兽处理类:炼化处理(连接id, 序号, id, 内容)
	local 物品 = 内容.序列
	local 认证码 = 内容.序列1
	local bb = nil

	for k, v in pairs(self.数据) do
		if v.认证码 == 认证码 then
			bb = k

			break
		end
	end

	if bb == nil then
		常规提示(id, "召唤兽数据异常2，请重新打开界面进行操作。")

		return
	end

	local 物品数据 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]]
	local 物品名称 = 物品数据.名称
	local 行囊格子 = 玩家数据[id].角色:取道具格子()

	if 行囊格子 == 0 then
		常规提示(id, "您的道具栏物品已经满啦")

		return
	end

	if 物品名称 == nil or self.数据[bb] == nil then
		return
	elseif self.数据[bb].参战信息 ~= nil then
		常规提示(id, "请先取消召唤兽的参战状态")

		return
	elseif self.数据[bb].种类 == "孩子" then
		常规提示(id, "孩子不能进行炼化")

		return
	elseif self.数据[bb].种类 == "神兽" then
		常规提示(id, "神兽不能进行炼化")

		return
	elseif self.数据[bb].最初模型 ~= nil then
		常规提示(id, "更换过模型的召唤兽无法炼化。")

		return
	elseif 物品名称 == "炼妖石" then
		local 临时等级 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].级别限制
		local 临时灵气 = qz1(self.数据[bb].等级 / 10)
		local 成功几率 = 25 + qz1(self.数据[bb].等级 / 10)

		if self.数据[bb].种类 == "宝宝" then
			成功几率 = 成功几率 + 10
			临时灵气 = 临时灵气 + 5
		elseif self.数据[bb].种类 == "变异" then
			成功几率 = 成功几率 + 45
			临时灵气 = 临时灵气 + 15
		end

		if math.ceil(取随机数(1, 10000) / 100) <= 成功几率 then
			local jl = math.ceil(取随机数(1, 10000) / 100)
			local 新格子 = 玩家数据[id].道具:取新编号()
			玩家数据[id].道具.数据[新格子] = DeepCopy(玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]])
			玩家数据[id].角色.数据.道具[行囊格子] = 新格子
			玩家数据[id].道具.数据[新格子].数量 = nil
			玩家数据[id].道具.数据[新格子].可叠加 = false

			if jl <= 10 then
				玩家数据[id].道具.数据[新格子].名称 = "九眼天珠"
			elseif jl <= 40 then
				玩家数据[id].道具.数据[新格子].名称 = "三眼天珠"
			else
				玩家数据[id].道具.数据[新格子].名称 = "天眼珠"
			end

			玩家数据[id].道具.数据[新格子].灵气 = 临时灵气 + math.max(ygsj(70), 35)
			玩家数据[id].道具.数据[新格子].分类 = 11

			if 玩家数据[id].道具.数据[新格子].灵气 > 100 then
				玩家数据[id].道具.数据[新格子].灵气 = 100
			end

			刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
			扣除背包位置道具(id, 物品, 1)
			常规提示(id, "炼化成功！")
		else
			扣除背包位置道具(id, 物品, 1)
			常规提示(id, "很遗憾，本次炼化失败了！")
		end

		table.remove(self.数据, bb)
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 24)
		发送数据(连接id, 26)

		return
	elseif 物品名称 == "圣兽丹" then
		local 成功几率 = 1

		if self.数据[bb].种类 == "宝宝" then
			成功几率 = 成功几率 + 2
		end

		if self.数据[bb].种类 == "变异" then
			成功几率 = 成功几率 + 3
		end

		if ygsj() <= 成功几率 then
			玩家数据[id].道具:给予道具(id, "宠物饰品通用丹")
			常规提示(id, "炼化成功")
		else
			常规提示(id, "很遗憾，本次炼化失败了！！！")
		end

		玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 - 1

		if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
			玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
			玩家数据[id].角色.数据.道具[物品] = nil
		end

		刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
		table.remove(self.数据, bb)
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 24)
		发送数据(连接id, 26)
	elseif 物品名称 == "怪物卡片" then
		if 物品数据.等级 ~= nil then
			local 卡片次数 = 物品数据.次数 + 0

			if 物品数据.次数 <= 1 then
				常规提示(id, "变身卡使用次数不足、无法点化。")

				return
			end

			local 卡片级别 = 物品数据.等级
			local 炼化级别 = 变身卡等级[self.数据[bb].模型]

			if 炼化级别 ~= nil and (卡片级别 < 炼化级别 or 卡片级别 == 10 and 炼化级别 == 10) then
				if 卡片级别 >= 7 and self.数据[bb].种类 == "野怪" then
					常规提示(id, "无法使用野怪点化大于6级的变身卡！")

					return
				end

				local 新卡片等级 = math.min(卡片级别 + 1, 10)
				local gl = 80

				if 新卡片等级 == 3 then
					gl = 70
				elseif 新卡片等级 == 4 then
					gl = 60
				elseif 新卡片等级 == 5 then
					gl = 50
				elseif 新卡片等级 == 6 then
					gl = 40
				elseif 新卡片等级 == 7 then
					gl = 30
				elseif 新卡片等级 == 8 then
					gl = 20
				elseif 新卡片等级 == 9 then
					gl = 10
				elseif 新卡片等级 == 10 then
					gl = 3
				end

				if ygsj() <= gl then
					local 新卡片造型 = ""

					if 炼化级别 == 新卡片等级 and ygsj() <= 30 then
						新卡片造型 = self.数据[bb].模型 .. ""
					else
						新卡片造型 = 变身卡范围[新卡片等级][ygsj(#变身卡范围[新卡片等级])]
					end

					if 变身卡数据[新卡片造型] ~= nil then
						if (物品数据.数量 or 1) > 1 then
							物品数据.数量 = 物品数据.数量 - 1
							local 新格子 = 玩家数据[id].道具:取新编号()
							玩家数据[id].角色.数据.道具[行囊格子] = 新格子
							玩家数据[id].道具.数据[新格子] = DeepCopy(物品数据)
							local 新物品 = 玩家数据[id].道具.数据[新格子]
							新物品.数量 = 1
							新物品.单独 = nil

							for k, v in pairs(变身卡数据[新卡片造型]) do
								新物品[k] = v
							end

							新物品.造型 = 新卡片造型
							新物品.次数 = qz(卡片次数 / 2)

							刷新道具行囊单格(id, "道具", 行囊格子, 新格子)
						else
							物品数据.单独 = nil

							for k, v in pairs(变身卡数据[新卡片造型]) do
								物品数据[k] = v
							end

							物品数据.造型 = 新卡片造型
							物品数据.次数 = qz(卡片次数 / 2)
						end

						刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
					end

					常规提示(id, "点化成功、你获得了#P" .. 新卡片造型 .. "#Y怪物卡片！")
				else
					常规提示(id, "很遗憾、点化失败了！")
				end

				table.remove(self.数据, bb)
				发送数据(连接id, 16, self.数据)
				发送数据(连接id, 24)
				发送数据(连接id, 26)
			else
				常规提示(id, "变身卡等级与所要炼化的召唤兽不匹配、无法点化。#P(所要炼化的召唤兽对应变身卡级别需大于放置的怪物卡片等级)")

				return
			end
		else
			常规提示(id, "变身卡数据出错。")

			return
		end
	elseif 物品名称 == "吸附石" then
		if ygsj() <= 吸附石几率 then
			local 吸附技能 = self.数据[bb].技能[ygsj(#self.数据[bb].技能)]

			玩家数据[id].道具:给予道具(id, "点化石", 1, 吸附技能)
			常规提示(id, "恭喜你获得了一个#R" .. 吸附技能 .. "#Y点化石")

			if 特殊兽决1[吸附技能] ~= nil then
				广播消息({
					频道 = "xt",
					内容 = format("#P(吸附石)#R/%s#Y使用吸附石炼化过程中居然点化出了一个#G%s#Y点化石" .. "#" .. 取随机数(1, 110), 玩家数据[id].角色.数据.名称, 吸附技能)
				})
			end
		else
			常规提示(id, "很遗憾，本次炼化失败了！！！")
		end

		玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 - 1

		if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
			玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
			玩家数据[id].角色.数据.道具[物品] = nil
		end

		刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
		table.remove(self.数据, bb)
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 24)
		发送数据(连接id, 26)
	else
		常规提示(id, "这是什么东西")
	end
end

function 召唤兽处理类:还原进阶造型处理(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要更改造型的召唤兽设置为参战！")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 ~= nil then
		常规提示(id, "该召唤兽改变过模型、无法进阶。")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].进阶 == false then
		添加最后对话(id, "该召唤兽尚未进阶，你是来寻我开心的吗？")

		return
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].模型 = 玩家数据[id].召唤兽.数据[参战召唤兽].迭代模型 or string.gsub(玩家数据[id].召唤兽.数据[参战召唤兽].模型, "进阶", "")
	玩家数据[id].召唤兽.数据[参战召唤兽].名称 = 玩家数据[id].召唤兽.数据[参战召唤兽].模型
	玩家数据[id].召唤兽.数据[参战召唤兽].进阶 = false

	常规提示(id, "召唤兽进阶造型还原成功！")
end

function 召唤兽处理类:进阶造型处理(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要更改造型的召唤兽设置为参战！")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].灵性 < 50 then
		常规提示(id, "该召唤兽没有达到更改造型的要求,灵性不能小于50")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 ~= nil then
		常规提示(id, "该召唤兽改变过模型、无法进阶。")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].进阶 then
		添加最后对话(id, "该召唤兽已经改变造型了，你是来寻我开心的吗？")

		return
	elseif 可进阶宝宝列表["进阶" .. string.gsub(玩家数据[id].召唤兽.数据[参战召唤兽].模型, "x", "")] == nil then
		常规提示(id, "该召唤兽没有进阶造型，无法进阶")

		return
	end

	if string.find(玩家数据[id].召唤兽.数据[参战召唤兽].模型, "x") then
		玩家数据[id].召唤兽.数据[参战召唤兽].迭代模型 = 玩家数据[id].召唤兽.数据[参战召唤兽].模型 .. ""
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].模型 = "进阶" .. string.gsub(玩家数据[id].召唤兽.数据[参战召唤兽].模型, "x", "")
	玩家数据[id].召唤兽.数据[参战召唤兽].名称 = 玩家数据[id].召唤兽.数据[参战召唤兽].模型
	玩家数据[id].召唤兽.数据[参战召唤兽].进阶 = true

	常规提示(id, "恭喜你，该召唤兽更改为新的造型了")
end

function 召唤兽处理类:染色还原(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要更改造型的召唤兽设置为参战！")

		return
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色方案 = nil
	玩家数据[id].召唤兽.数据[参战召唤兽].染色方案 = nil

	常规提示(id, "恭喜你，该召唤兽染色状态还原了")
end

function 召唤兽处理类:给予自选神兽(id, 种类, 类型)
	if 玩家数据[id].角色.数据.召唤兽携带数量 <= #玩家数据[id].召唤兽.数据 then
		常规提示(id, "#Y/你目前最多只能携带#R" .. 玩家数据[id].角色.数据.召唤兽携带数量 .. "只召唤兽")

		return
	elseif 种类 == nil or 神兽列表1[种类] == nil then
		常规提示(id, "#Y/神兽种类数据错误。")

		return
	elseif 扣除道具(id, "神兽自选礼包", 1) == false then
		常规提示(id, "你身上没有#P神兽自选礼包")

		return
	end

	if 类型 == "法术型" then
		self:添加召唤兽(种类, false, false, true, 0, "法系", nil, nil, nil, nil, nil, {
			自选神兽 = 1
		})
	else
		self:添加召唤兽(种类, false, false, true, 0, nil, nil, nil, nil, nil, nil, {
			自选神兽 = 1
		})
	end

	常规提示(id, "恭喜你获得了一只#P" .. 种类 .. "(" .. 类型 .. ")#Y！")
end

function 召唤兽处理类:神兽类型转换(id, 类型)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要转换类型的神兽设置为参战！")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].种类 ~= "神兽" then
		添加最后对话(id, "你的这只召唤兽不是神兽，无法进行类型转换。")

		return
	end

	local 神兽类型 = nil
	local 神兽类型1 = "法系"
	local 改变 = "法术型"

	if 类型 == "法术型" then
		神兽类型 = "法系"
		神兽类型1 = nil
		改变 = "物理型"
	end

	local 神兽资质 = 取神兽资质(玩家数据[id].召唤兽.数据[参战召唤兽].模型, 神兽类型)
	local 神兽资质1 = 取神兽资质(玩家数据[id].召唤兽.数据[参战召唤兽].模型, 神兽类型1)

	if 神兽资质[8] ~= nil and 神兽资质1[8] ~= nil then
		for i = 1, #神兽资质[8] do
			if 神兽资质[8][i] ~= 玩家数据[id].召唤兽.数据[参战召唤兽].技能[i] then
				常规提示(id, "#Y你的这只神兽#P并非初始神兽#Y或#P类型选择错误#Y、更改类型失败！")

				return
			end
		end
	else
		常规提示(id, "#Y神兽模型信息错误、更改类型失败！")

		return
	end

	if 扣除道具(id, "神兜兜", 神兽类型转换神兜兜数量) == false then
		添加最后对话(id, "你身上的神兜兜不足" .. 神兽类型转换神兜兜数量 .. "个。")

		return
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].技能 = DeepCopy(神兽资质1[8])

	常规提示(id, "恭喜你的#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y成功更改神兽类型为#P" .. 改变 .. "#Y!")
end

function 召唤兽处理类:生命升华处理(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要生命升华的召唤兽设置为参战！")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].种类 == "神兽" then
		添加最后对话(id, "你的这只召唤兽已经是神兽了，无需进行生命升华。")

		return
	end

	if 扣除道具(id, "神兜兜", 生命升华神兜兜数量) == false then
		添加最后对话(id, "你身上的神兜兜不足" .. 生命升华神兜兜数量 .. "个。")

		return
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].种类 = "神兽"

	if 玩家数据[id].召唤兽.数据[参战召唤兽].转生 ~= nil and 玩家数据[id].召唤兽.数据[参战召唤兽].转生 >= 1 then
		for i = 1, 玩家数据[id].召唤兽.数据[参战召唤兽].转生 do
			self:神兽转生添加技能(id, 参战召唤兽, i)
		end
	end

	self:洗点处理1(参战召唤兽)
	常规提示(id, "恭喜你的#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y生命升华为#R【神兽】#Y！")
end

function 召唤兽处理类:神兽转生添加技能(id, 参战召唤兽, 转生次数)
	if 玩家数据[id].召唤兽.数据[参战召唤兽].种类 == "神兽" and 玩家数据[id].召唤兽.数据[参战召唤兽].技能 ~= nil and #玩家数据[id].召唤兽.数据[参战召唤兽].技能 < 36 then
		if 转生次数 == 1 then
			self:GM添加技能(id, {
				召唤兽转生技能[1].通用
			}, 1)
		elseif 转生次数 == 2 then
			if 召唤兽转生技能[2][玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 or 玩家数据[id].召唤兽.数据[参战召唤兽].模型] ~= nil then
				self:GM添加技能(id, {
					召唤兽转生技能[2][玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 or 玩家数据[id].召唤兽.数据[参战召唤兽].模型]
				}, 1)
			else
				self:GM添加技能(id, {
					召唤兽转生技能[2].通用
				}, 1)
			end
		end
	end
end

function 召唤兽处理类:神兽转生处理(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要转生的召唤兽设置为参战！")

		return
	end

	if 玩家数据[id].召唤兽.数据[参战召唤兽].转生 ~= nil and 召唤兽转生次数 <= 玩家数据[id].召唤兽.数据[参战召唤兽].转生 then
		常规提示(id, "转生失败，你的这只召唤兽已经达到转生次数上限！")

		return
	end

	local sl = (玩家数据[id].召唤兽.数据[参战召唤兽].转生 or 0) * 100 + 99

	if 扣除道具(id, "神兜兜", sl) == false then
		添加最后对话(id, "你身上的神兜兜不足" .. sl .. "个。")

		return
	end

	if 玩家数据[id].召唤兽.数据[参战召唤兽].转生 == nil then
		玩家数据[id].召唤兽.数据[参战召唤兽].转生 = 0
	end

	local 资质列表 = {
		"攻击资质",
		"防御资质",
		"体力资质",
		"法力资质",
		"速度资质",
		"躲闪资质",
		"成长"
	}

	for i = 1, #资质列表 do
		玩家数据[id].召唤兽.数据[参战召唤兽][资质列表[i]] = 玩家数据[id].召唤兽.数据[参战召唤兽][资质列表[i]] + 召唤兽转生加成[资质列表[i]]
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].转生 = 玩家数据[id].召唤兽.数据[参战召唤兽].转生 + 1

	self:神兽转生添加技能(id, 参战召唤兽, 玩家数据[id].召唤兽.数据[参战召唤兽].转生)
	self:洗点处理1(参战召唤兽)
	常规提示(id, "恭喜你，召唤兽转生成功！剩余转生次数为#R" .. 召唤兽转生次数 - 玩家数据[id].召唤兽.数据[参战召唤兽].转生)
end

function 召唤兽处理类:GM修改资质(id, 数值, 类别)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要添加技能的召唤兽设置为参战！")

		return
	end

	local lb = {
		"攻击资质",
		"防御资质",
		"体力资质",
		"法力资质",
		"速度资质",
		"躲闪资质",
		"寿命",
		"成长"
	}
	数值 = 数值 + 0

	if 数值 > 0 then
		类别 = 类别 + 0

		if 类别 ~= 8 then
			数值 = math.floor(数值)
		end

		玩家数据[id].召唤兽.数据[参战召唤兽][lb[类别]] = 数值

		常规提示(id, "#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y修改#R" .. lb[类别] .. "#Y成功！")
		self:刷新信息(参战召唤兽, nil, nil, id)
	else
		常规提示(id, "#G错误参数！#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y修改#R" .. lb[类别] .. "#Y失败！")
	end
end

function 召唤兽处理类:GM添加技能(id, 技能组, 模式)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i

			break
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要添加技能的召唤兽设置为参战！")

		return
	end

	local 原有技能 = {}

	if 玩家数据[id].召唤兽.数据[参战召唤兽].法术认证 ~= nil and 玩家数据[id].召唤兽.数据[参战召唤兽].法术认证[1] ~= nil then
		原有技能[1] = 玩家数据[id].召唤兽.数据[参战召唤兽].法术认证[1]
	end

	原有技能 = 列表模式转换(列表2加入到列表1(玩家数据[id].召唤兽.数据[参战召唤兽].技能, 原有技能))
	删除技能 = {}
	技能总数 = #玩家数据[id].召唤兽.数据[参战召唤兽].技能 + 0

	for i = 1, #技能组 do
		if 模式 == 1 then
			if 原有技能[技能组[i]] == nil then
				玩家数据[id].召唤兽.数据[参战召唤兽].技能[#玩家数据[id].召唤兽.数据[参战召唤兽].技能 + 1] = 技能组[i]
				原有技能[技能组[i]] = 1

				常规提示(id, "#Y恭喜你的#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y获得新技能：#R" .. 技能组[i] .. "#Y！")
			else
				常规提示(id, "#Y你的#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y已有#R" .. 技能组[i] .. "#Y技能！")
			end
		elseif 模式 == 2 then
			if 原有技能[技能组[i]] ~= nil then
				删除技能[#删除技能 + 1] = 原有技能[技能组[i]] + 0
				原有技能[技能组[i]] = nil

				常规提示(id, "#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y删除技能#R" .. 技能组[i] .. "#Y成功！")
			else
				常规提示(id, "#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y没有#R" .. 技能组[i] .. "#Y技能，删除失败！")
			end
		elseif 模式 == 3 then
			玩家数据[id].召唤兽.数据[参战召唤兽].法术认证 = nil
			玩家数据[id].召唤兽.数据[参战召唤兽].技能 = {}

			常规提示(id, "#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].名称 .. "#Y技能清空#Y成功！")
			self:刷新信息(参战召唤兽, nil, nil, id)

			return
		end
	end

	if #删除技能 > 0 then
		table.sort(删除技能, function (a, b)
			return a < b
		end)

		local 已删 = 0

		for i = 1, #删除技能 do
			if 删除技能[i] == 技能总数 + 1 then
				玩家数据[id].召唤兽.数据[参战召唤兽].法术认证 = nil
			else
				table.remove(玩家数据[id].召唤兽.数据[参战召唤兽].技能, 删除技能[i] - 已删)

				已删 = 已删 + 1
			end
		end
	end

	self:刷新信息(参战召唤兽, nil, nil, id)
end

取当前召唤兽是否孩子 = function(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		return
	end

	if 玩家数据[id].召唤兽.数据[参战召唤兽].种类 == "孩子" or 玩家数据[id].召唤兽.数据[参战召唤兽].门派 ~= nil or (玩家数据[id].召唤兽.数据[参战召唤兽].孩子书 or 0) > 0 then
		return true
	else
		return false
	end
end

召唤兽更换模型 = function(id, 新模型)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要更改造型的召唤兽设置为参战！")

		return
	end

	if 扣除道具(id, "神兜兜", 更改模型神兜兜数量) == false then
		return
	end

	if 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 == nil then
		玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 = 玩家数据[id].召唤兽.数据[参战召唤兽].模型 .. ""

		if 玩家数据[id].召唤兽.数据[参战召唤兽].不可交易 == true then
			玩家数据[id].召唤兽.数据[参战召唤兽].初始绑定状态 = true
		else
			玩家数据[id].召唤兽.数据[参战召唤兽].初始绑定状态 = false
		end
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].不可交易 = true
	玩家数据[id].召唤兽.数据[参战召唤兽].模型 = 新模型
	玩家数据[id].召唤兽.数据[参战召唤兽].名称 = 新模型
	玩家数据[id].召唤兽.数据[参战召唤兽].进阶 = false
	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色方案 = nil
	玩家数据[id].召唤兽.数据[参战召唤兽].染色方案 = nil

	常规提示(id, "恭喜你，该召唤兽更改为新的造型：#R" .. 新模型)
end

召唤兽还原模型 = function(id)
	local 参战召唤兽 = 0

	for i = 1, #玩家数据[id].召唤兽.数据 do
		if 玩家数据[id].召唤兽.数据[i].参战信息 ~= nil then
			参战召唤兽 = i
		end
	end

	if 参战召唤兽 == 0 then
		常规提示(id, "请先将要还原造型的召唤兽设置为参战！")

		return
	elseif 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 == nil then
		常规提示(id, "你的召唤兽没有更换过模型、无需还原！")

		return
	end

	if 扣除道具(id, "神兜兜", qz(更改模型神兜兜数量 / 10)) == false then
		return
	end

	玩家数据[id].召唤兽.数据[参战召唤兽].模型 = 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 .. ""
	玩家数据[id].召唤兽.数据[参战召唤兽].名称 = 玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 .. ""
	玩家数据[id].召唤兽.数据[参战召唤兽].最初模型 = nil
	玩家数据[id].召唤兽.数据[参战召唤兽].进阶 = false
	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].染色组 = {}
	玩家数据[id].召唤兽.数据[参战召唤兽].饰品染色方案 = nil
	玩家数据[id].召唤兽.数据[参战召唤兽].染色方案 = nil

	if 玩家数据[id].召唤兽.数据[参战召唤兽].初始绑定状态 == false then
		玩家数据[id].召唤兽.数据[参战召唤兽].不可交易 = nil
		玩家数据[id].召唤兽.数据[参战召唤兽].初始绑定状态 = nil
	end

	常规提示(id, "还原成功！该召唤兽已还原为最初的模型：#R" .. 玩家数据[id].召唤兽.数据[参战召唤兽].模型)
end

function 召唤兽处理类:打书确认(连接id, 序号, id, 内容)
	if 内容.是否确认 == true then
		local 携带技能 = 内容.学习技能
		local 格子编号 = 内容.格子编号
		local 宝宝编号 = 内容.宝宝编号
		local 遗忘技能 = 内容.遗忘技能

		if self.数据[宝宝编号].技能[格子编号] == 遗忘技能 then
			self.数据[宝宝编号].技能[格子编号] = 携带技能

			常规提示(id, "你的这只召唤兽学会了新技能#R/" .. 携带技能 .. "#Y/ 但是遗忘了#R/ " .. 遗忘技能)

			self.数据[宝宝编号].技能 = 列表打乱重组(self.数据[宝宝编号].技能)

			发送数据(连接id, 16, self.数据)
			发送数据(连接id, 96)
		end
	end
end

function 召唤兽处理类:洗练处理(连接id, 序号, id, 内容)
	local 物品 = 内容.序列
	local 认证码 = 内容.序列1
	local 选择内丹 = 内容.序列2
	local bb = nil

	if 物品 == "打书刷新物品" or 物品 == "内丹刷新物品" then
		发送数据(连接id, 96)

		return
	elseif 物品 == "洗练刷新物品" or 物品 == "炼化刷新物品" then
		发送数据(连接id, 24)

		return
	end

	for k, v in pairs(self.数据) do
		if v.认证码 == 认证码 then
			bb = k

			break
		end
	end

	if bb == nil then
		常规提示(id, "召唤兽数据异常1，请重新打开界面进行操作。")

		return
	end

	local 物品名称 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].名称
	local 携带技能 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].附带技能
	local 格子编号 = 0

	if 物品名称 == nil or self.数据[bb] == nil then
		return
	elseif 物品名称 == "金柳露" or 物品名称 == "超级金柳露" then
		if self.数据[bb].种类 == "神兽" then
			常规提示(id, "金柳露不用作用于神兽身上")

			return
		elseif self.数据[bb].最初模型 ~= nil then
			常规提示(id, "更换过模型的召唤兽无法洗练。")

			return
		elseif self.数据[bb].进阶 then
			常规提示(id, "金柳露不用作用于进阶召唤兽身上")

			return
		elseif self:是否有装备(bb) then
			常规提示(id, "请先卸下召唤兽所穿戴的装备")

			return
		elseif self.数据[bb].内丹.可用内丹 == 0 then
			常规提示(id, "有内丹的召唤兽无法使用")

			return
		elseif 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 == nil then
			常规提示(id, "这种金柳露已经作废无法使用,请重新购买")

			return
		end

		self:解除统御助战(连接id, id, bb, 1)

		local 变异 = false
		local 超级 = 0
		local 变异保底 = (self.数据[bb].变异保底 or 0) + 0
		local 消耗数量 = 0

		if 内容.一键变异 == true and self.数据[bb].种类 ~= "变异" then
			local 物品数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) + 0
			local 变异概率 = 金柳露变异概率

			if 物品名称 == "超级金柳露" then
				变异概率 = 超级金柳露变异概率
			end

			for i = 1, 物品数量 do
				消耗数量 = 消耗数量 + 1

				if 变异 == false and (ygsj(1000) <= 变异概率 * (一键顶书概率比例 - 0.3) or 变异保底 >= 洗宝宝变异保底次数 - 1) then
					变异 = true

					常规提示(id, "恭喜你，该召唤兽发生了变异")
					常规提示(id, "#P(一键变异)#Y恭喜！你消耗了#S" .. i .. "#Y个#G" .. 物品名称 .. "#Y、你的召唤兽成功#S变异#Y了！")

					break
				else
					变异保底 = 变异保底 + 1

					if i == 物品数量 then
						常规提示(id, "#P(一键变异)#Y很遗憾！你消耗了#R" .. i .. "#Y个#G" .. 物品名称 .. "#Y、洗变异#R失败#Y！")
					end
				end
			end
		else
			消耗数量 = 1

			if self.数据[bb].种类 == "变异" then
				变异 = true
			end

			if 物品名称 == "金柳露" then
				if 变异 == false and (取随机数(1, 10000) <= 金柳露变异概率 * 10 or 变异保底 >= 洗宝宝变异保底次数 - 1) then
					变异 = true

					常规提示(id, "恭喜你，该召唤兽发生了变异")
				else
					变异保底 = 变异保底 + 1
				end
			else
				超级 = 1

				if 变异 == false and (取随机数(1, 10000) <= 超级金柳露变异概率 * 10 or 变异保底 >= 洗宝宝变异保底次数 - 1) then
					变异 = true

					常规提示(id, "恭喜你，该召唤兽发生了变异")
				else
					变异保底 = 变异保底 + 1
				end
			end
		end

		self:添加召唤兽(self.数据[bb].模型, true, 变异, false, 0, nil, bb, nil, nil, 超级, self.数据[bb].不可交易)

		self.数据[bb].当前经验 = 0

		if self.数据[bb].种类 ~= "变异" then
			self.数据[bb].变异保底 = 变异保底
		end

		玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 消耗数量

		if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
			玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
			玩家数据[id].角色.数据.道具[物品] = nil
		end

		刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
		发送数据(连接id, 16, self.数据)
		发送数据(连接id, 24)
		发送数据(连接id, 25)
		常规提示(id, "使用" .. 物品名称 .. "成功")

		return
	elseif 物品名称 == "魔兽要诀" or 物品名称 == "高级魔兽要诀" or 物品名称 == "特殊魔兽要诀" or 物品名称 == "神兽兽决" then
		self.数据[bb].自动指令 = nil
		local 技能重复 = 0

		if self.数据[bb].技能 == nil or self.数据[bb].技能 == 0 then
			self.数据[bb].技能[1] = 携带技能
		end

		for n = 1, #self.数据[bb].技能 do
			if self.数据[bb].技能[n] == 携带技能 then
				技能重复 = n
			end
		end

		if 技能重复 == 0 then
			local 扣除数量 = 1

			if 内容.一键顶书 ~= nil and 是否月卡用户(id) == true then
				if 打书模式 == 1 then
					local 次数 = 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1

					for i = 1, 次数 do
						扣除数量 = i + 0

						if self:打书概率(#self.数据[bb].技能, "一键顶书") then
							格子编号 = #self.数据[bb].技能 + 1
							self.数据[bb].技能[格子编号] = 携带技能
							self.数据[bb].技能 = 列表打乱重组(self.数据[bb].技能)

							发送数据(连接id, 16, self.数据)
							常规提示(id, "#P(一键顶书)#Y恭喜！你消耗了#S" .. i .. "#Y本#G" .. 物品名称 .. "(" .. 携带技能 .. ")#Y、你的这只召唤兽学会了新技能#P/" .. 携带技能)

							break
						elseif i == 次数 then
							常规提示(id, "#P(一键顶书)#Y很遗憾！你消耗了#R" .. i .. "#Y本#G" .. 物品名称 .. "(" .. 携带技能 .. ")#Y、顶书失败！")
						end
					end
				else
					常规提示(id, "服务器当前打书模式不支持一键顶书、已按#P正常打书操作#Y处理。")
				end
			elseif self:打书概率(#self.数据[bb].技能) then
				格子编号 = #self.数据[bb].技能 + 1
				self.数据[bb].技能[格子编号] = 携带技能
				self.数据[bb].技能 = 列表打乱重组(self.数据[bb].技能)

				发送数据(连接id, 16, self.数据)
				常规提示(id, "你的这只召唤兽学会了新技能#R/" .. 携带技能)
			else
				格子编号 = 取随机数(1, #self.数据[bb].技能)

				if self.数据[bb].法术认证 ~= nil and self.数据[bb].技能[格子编号] == self.数据[bb].法术认证 then
					while self.数据[bb].技能[格子编号] == self.数据[bb].法术认证 do
						格子编号 = 取随机数(1, #self.数据[bb].技能)
					end
				end

				if 打书模式 == 1 then
					发送数据(连接id, 16.9, {
						宝宝编号 = bb,
						遗忘技能 = self.数据[bb].技能[格子编号],
						学习技能 = 携带技能,
						格子编号 = 格子编号
					})
				else
					常规提示(id, "你的这只召唤兽学会了新技能#R/" .. 携带技能 .. "#Y/ 但是遗忘了#R/ " .. self.数据[bb].技能[格子编号])

					self.数据[bb].技能[格子编号] = 携带技能

					发送数据(连接id, 16, self.数据)
				end
			end

			玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 扣除数量

			if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
				玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
				玩家数据[id].角色.数据.道具[物品] = nil
			end

			刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
			发送数据(连接id, 95)
			发送数据(连接id, 96)
		else
			常规提示(id, "你的这只召唤兽已学会该技能,无法再学习")
		end
	elseif 物品名称 == "召唤兽内丹" or 物品名称 == "高级召唤兽内丹" then
		self.数据[bb].自动指令 = nil
		local 内丹属性 = self.数据[bb].内丹

		if #内丹属性 >= 1 then
			for n = 1, #内丹属性 do
				if 内丹属性[n].技能 == 携带技能 then
					if 内丹属性[n].等级 == 5 then
						常规提示(id, "该内丹已学满")

						return
					else
						local 所需数量 = 内丹属性[n].等级 + 1

						if 所需数量 > (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) then
							常规提示(id, "内丹数量不足、当前需要#P" .. 所需数量 .. "#Y个")

							return
						end

						self.数据[bb].内丹[n].等级 = self.数据[bb].内丹[n].等级 + 1
						玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 所需数量

						if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
							玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
							玩家数据[id].角色.数据.道具[物品] = nil
						end

						刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
						常规提示(id, "恭喜你的" .. self.数据[bb].名称 .. "#R/" .. 内丹属性[n].技能 .. "#Y/升到第#R/" .. self.数据[bb].内丹[n].等级 .. "#Y/层")
						self:刷新信息(bb)
						发送数据(连接id, 16, self.数据)
						发送数据(连接id, 95)
						发送数据(连接id, 96)

						return
					end
				elseif 内丹属性[n + 1] == nil then
					if 内丹属性.可用内丹 > 0 then
						self.数据[bb].内丹[n + 1] = {}
						self.数据[bb].内丹[n + 1].技能 = 携带技能
						self.数据[bb].内丹[n + 1].等级 = 1
						self.数据[bb].内丹.可用内丹 = self.数据[bb].内丹.可用内丹 - 1
						玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 1

						if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
							玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
							玩家数据[id].角色.数据.道具[物品] = nil
						end

						刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
						常规提示(id, "恭喜你的" .. self.数据[bb].名称 .. "学会了#R/" .. 携带技能)
						self:刷新信息(bb)
						发送数据(连接id, 16, self.数据)
						发送数据(连接id, 95)
						发送数据(连接id, 96)
					else
						self.随机位置 = 选择内丹

						if self.随机位置 == 0 then
							常规提示(id, "请选择需要覆盖的内丹")

							return
						end

						if 携带技能 ~= 内丹属性[n].技能 then
							常规提示(id, "你的召唤兽" .. self.数据[bb].名称 .. "遗忘了#R/" .. self.数据[bb].内丹[self.随机位置].技能)

							self.数据[bb].内丹[self.随机位置] = {
								技能 = 携带技能,
								等级 = 1
							}
							玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 1

							if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
								玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
								玩家数据[id].角色.数据.道具[物品] = nil
							end

							刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
							常规提示(id, "恭喜你的" .. self.数据[bb].名称 .. "学会了#R/" .. 携带技能)
							self:刷新信息(bb)
							发送数据(连接id, 16, self.数据)
							发送数据(连接id, 95)
							发送数据(连接id, 96)
						end
					end
				end
			end
		else
			self.数据[bb].内丹[1] = {
				技能 = 携带技能,
				等级 = 1
			}
			self.数据[bb].内丹.可用内丹 = self.数据[bb].内丹.可用内丹 - 1
			玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 = (玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 or 1) - 1

			if 玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]].数量 < 1 then
				玩家数据[id].道具.数据[玩家数据[id].角色.数据.道具[物品]] = nil
				玩家数据[id].角色.数据.道具[物品] = nil
			end

			刷新道具行囊单格(id, "道具", 物品, 玩家数据[id].角色.数据.道具[物品])
			常规提示(id, "恭喜你的" .. self.数据[bb].名称 .. "学会了#R/" .. 携带技能)
			self:刷新信息(bb)
			发送数据(连接id, 16, self.数据)
			发送数据(连接id, 95)
			发送数据(连接id, 96)
		end
	end
end

function 召唤兽处理类:升级超级技能(连接id, id)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要升级超级技能的召唤兽参战")

		return
	end

	local 超级技能 = {}
	local 临时选项 = {}

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			for i = 1, #self.数据[n].技能 do
				if 超级技能列表[self.数据[n].技能[i]] ~= nil then
					超级技能[#超级技能 + 1] = self.数据[n].技能[i]
				end
			end

			if self.数据[n].法术认证 ~= nil and self.数据[n].法术认证[1] ~= nil and 超级技能列表[self.数据[n].法术认证[1]] ~= nil then
				超级技能[#超级技能 + 1] = self.数据[n].法术认证[1]
			end

			break
		end
	end

	if #超级技能 >= 1 then
		for i = 1, #超级技能 do
			临时选项[i] = 超级技能[i]
		end

		临时选项[#临时选项 + 1] = "稍等、容我再考虑一下"

		发送数据(连接id, 1501, {
			名称 = 玩家数据[id].最后对话.名称,
			模型 = 玩家数据[id].最后对话.模型,
			对话 = format("少侠要对该召唤兽的哪个高级技能进行超级升级呢？"),
			选项 = 临时选项
		})
	else
		添加最后对话(id, "该召唤兽没有可升级超级技能的技能哦！")
	end
end

function 召唤兽处理类:升级超级技能处理(连接id, id, 事件)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要升级超级技能的召唤兽参战")

		return
	end

	local n = 0

	for i = 1, #self.数据 do
		if self.数据[i].参战信息 ~= nil and #self.数据[i].技能 ~= nil then
			n = i

			break
		end
	end

	if n == 0 then
		常规提示(id, "升级失败、召唤数据错误。")

		return
	elseif 超级技能数量限制 <= (self.数据[n].超级技能数量 or 0) then
		常规提示(id, "该召唤兽已经升级过#P" .. 超级技能数量限制 .. "#Y个超级技能了。")

		return
	elseif 扣除道具(id, "神兜兜", 超级技能神兜兜数量) == false then
		return
	end

	if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
		local aa = 超级技能列表[超级技能列表[事件]]

		if self.数据[n].法术认证 ~= nil and self.数据[n].法术认证[1] == 事件 then
			self.数据[n].法术认证[1] = aa
		else
			for i = 1, #self.数据[n].技能 do
				if self.数据[n].技能[i] == 事件 then
					self.数据[n].技能[i] = aa

					break
				end
			end
		end

		self.数据[n].超级技能数量 = (self.数据[n].超级技能数量 or 0) + 1

		常规提示(id, "升级超级技能成功、#G" .. self.数据[n].名称 .. "#Y还可升级#P" .. 超级技能数量限制 - self.数据[n].超级技能数量 .. "#Y个超级技能。")
		添加最后对话(id, "恭喜少侠、#G" .. self.数据[n].名称 .. "#W的#R" .. 事件 .. "#W升级为了#P" .. aa .. "#W！")
		self:刷新信息(n)
	end
end

function 召唤兽处理类:觉醒技能(连接id, id)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要觉醒技能的召唤兽参战")

		return
	end

	local 觉醒法术 = {}
	local 临时选项 = {}

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			for i = 1, #self.数据[n].技能 do
				if 觉醒技能列表[self.数据[n].技能[i]] ~= nil then
					觉醒法术[#觉醒法术 + 1] = self.数据[n].技能[i]
				end
			end

			if self.数据[n].法术认证 ~= nil and self.数据[n].法术认证[1] ~= nil and 觉醒技能列表[self.数据[n].法术认证[1]] ~= nil then
				觉醒法术[#觉醒法术 + 1] = self.数据[n].法术认证[1]
			end
		end
	end

	if #觉醒法术 >= 1 then
		for i = 1, #觉醒法术 do
			临时选项[i] = 觉醒法术[i]
		end

		临时选项[#临时选项 + 1] = "稍等、容我再考虑一下"

		发送数据(连接id, 1501, {
			名称 = 玩家数据[id].最后对话.名称,
			模型 = 玩家数据[id].最后对话.模型,
			对话 = format("少侠要对该召唤兽的哪个技能进行觉醒呢？"),
			选项 = 临时选项
		})
	else
		添加最后对话(id, "该召唤兽没有可觉醒的技能哦！")
	end
end

function 召唤兽处理类:觉醒技能处理(连接id, id, 事件)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要觉醒技能的召唤兽参战")

		return
	elseif 扣除道具(id, "神兜兜", 技能觉醒神兜兜数量) == false then
		return
	end

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			if self.数据[n].法术认证 ~= nil and self.数据[n].法术认证[1] == 事件 then
				self.数据[n].法术认证[1] = 事件 .. "·觉醒"

				添加最后对话(id, "少侠的召唤兽觉醒技能#R" .. 事件 .. "#Y成功！")

				return
			end

			for i = 1, #self.数据[n].技能 do
				if self.数据[n].技能[i] == 事件 then
					self.数据[n].技能[i] = 事件 .. "·觉醒"

					添加最后对话(id, "少侠的召唤兽觉醒技能#R" .. 事件 .. "#Y成功！")
					self:刷新信息(n)

					return
				end
			end
		end
	end
end

function 召唤兽处理类:法术认证(连接id, id)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要法术认证的召唤兽参战")

		return
	end

	local 认证法术 = {}
	local 临时选项 = {}

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			if self.数据[n].法术认证 ~= nil then
				常规提示(id, "已有认证技能，如需更换请先取消认证技能。")

				return
			end

			for i = 1, #self.数据[n].技能 do
				if 法术认证列表[self.数据[n].技能[i]] ~= nil then
					认证法术[#认证法术 + 1] = self.数据[n].技能[i]
				end
			end

			break
		end
	end

	if #认证法术 >= 1 then
		for i = 1, #认证法术 do
			临时选项[i] = 认证法术[i]
			临时选项[#认证法术 + 1] = "不认证了"

			发送数据(连接id, 1501, {
				名称 = "老马猴",
				模型 = "马猴",
				对话 = format("少侠要对该召唤兽的哪个技能进行认证呢？"),
				选项 = 临时选项
			})
		end
	else
		添加最后对话(id, "该召唤兽没有可认证的法术哦")
	end
end

function 召唤兽处理类:法术认证处理(连接id, id, 事件)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要法术认证的召唤兽参战")

		return
	elseif 取银子(id) < 1000000 then
		常规提示(id, "你的钱不够100万无法认证！")

		return
	end

	local 随机技能 = 取认证法术()

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			玩家数据[id].角色:扣除银子(1000000, 0, 0, "法术认证", 1)

			local aa = 列表模式转换(self.数据[n].技能)

			while aa[随机技能] ~= nil do
				随机技能 = 取认证法术()
			end

			for i = 1, #self.数据[n].技能 do
				if self.数据[n].技能[i] == 事件 then
					self.数据[n].技能[i] = 随机技能
					self.数据[n].法术认证 = {
						事件,
						随机技能
					}

					添加最后对话(id, "少侠的召唤兽法术认证成功")
					self:刷新信息(n)

					return
				end
			end
		end
	end
end

function 召唤兽处理类:取消法术认证(连接id, id)
	if 玩家数据[id].角色.数据.参战信息 == nil then
		常规提示(id, "请将要取消法术认证的召唤兽参战")

		return
	elseif 取银子(id) < 1000000 then
		常规提示(id, "你的钱不够100万无法取消！")

		return
	end

	for n = 1, #self.数据 do
		if self.数据[n].参战信息 ~= nil and #self.数据[n].技能 ~= nil then
			if self.数据[n].法术认证 == nil then
				常规提示(id, "你没有认证法术取消个毛啊")

				return
			end

			玩家数据[id].角色:扣除银子(1000000, 0, 0, "法术认证", 1)

			for i = 1, #self.数据[n].技能 do
				if self.数据[n].技能[i] == self.数据[n].法术认证[2] then
					self.数据[n].技能[i] = self.数据[n].法术认证[1]
					self.数据[n].法术认证 = nil

					添加最后对话(id, "少侠的召唤兽法术认证取消成功")
					self:刷新信息(n)

					return
				end
			end

			self.数据[n].技能[1] = self.数据[n].法术认证[1]
			self.数据[n].法术认证 = nil

			添加最后对话(id, "少侠的召唤兽法术认证取消成功")
			self:刷新信息(n)
		end
	end
end

function 召唤兽处理类:月卡自动喂养处理(id, 编号)
	if 编号 ~= nil and self.数据[编号] ~= nil and self.数据[编号].忠诚 < 71 and 玩家数据[id].角色.数据.月卡激活 ~= nil and 玩家数据[id].角色.数据.月卡激活 > 0 then
		local aa = true

		while aa and self.数据[编号].忠诚 < 100 do
			aa = 玩家数据[id].召唤兽:喂养处理(玩家数据[id].连接id, id, 编号, 1)
		end
	end
end

function 召唤兽处理类:喂养处理(连接id, id, 编号, 自动喂养)
	if 编号 == nil or self.数据[编号] == nil then
		if 自动喂养 == nil then
			常规提示(id, "召唤兽数据错误。")
		end

		return false
	end

	local zc = 20

	if self.数据[编号].忠诚 >= 100 then
		常规提示(id, "你的#P" .. self.数据[编号].名称 .. "#Y忠诚度已满、无需喂养。")

		return
	elseif 扣除道具(id, "高级宠物口粮", 1, 1) then
		zc = 50
		使用 = true
	elseif not 扣除道具(id, "宠物口粮", 1, 1) then
		if 自动喂养 == nil then
			常规提示(id, "喂养失败、你身上没有#S宠物口粮#Y。")
		else
			常规提示(id, "#P(月卡自动喂养)#Y喂养失败、你身上没有#S宠物口粮#Y。")
		end

		return false
	end

	local jc = math.min(self.数据[编号].忠诚 + zc, 100) - self.数据[编号].忠诚
	self.数据[编号].忠诚 = math.min(self.数据[编号].忠诚 + zc, 100)

	if 自动喂养 == nil then
		常规提示(id, "你的#P" .. self.数据[编号].名称 .. "#Y忠诚度增加了#R" .. qz1(jc) .. "#Y点。")
		发送数据(连接id, 17.5, {
			编号 = 编号,
			忠诚 = self.数据[编号].忠诚
		})
	end

	return true
end

function 召唤兽处理类:洗点处理(连接id, id, 编号)
	if 编号 == nil then
		if 玩家数据[id].角色.数据.参战信息 == nil then
			常规提示(id, "请将要洗点的召唤兽参战")

			return
		end

		for n = 1, #self.数据 do
			if self.数据[n].参战信息 ~= nil then
				if self.数据[n].种类 == "野怪" then
					常规提示(id, "野怪不能洗点")

					return
				end

				编号 = n

				break
			end
		end
	end

	if 扣除道具(id, "神兜兜", 1) == false then
		return
	end

	self:洗点处理1(编号)

	self.数据[编号].洗点次数 = (self.数据[编号].洗点次数 or 0) + 1

	常规提示(id, "召唤兽洗点成功！")
	发送数据(连接id, 17, self.数据)
end

function 召唤兽处理类:洗点处理1(编号)
	local 初始潜力 = 20
	local 神兽转生潜能点加成 = 0
	local 转生加成 = 0

	if self.数据[编号].转生 ~= nil then
		local ss = 1

		if self.数据[编号].种类 == "神兽" then
			ss = 2
		end

		转生加成 = 转生五维 * tonumber(self.数据[编号].转生) * ss
	end

	if self.数据[编号].种类 == "神兽" then
		初始潜力 = 神兽初始潜力

		if self.数据[编号].转生 ~= nil and self.数据[编号].转生 >= 2 then
			神兽转生潜能点加成 = 神兽转生潜能点加成 + qz(服务端参数.宝宝升级潜能点 / 5)
		end

		if self.数据[编号].天生神兽 == true then
			初始潜力 = 天生神兽初始潜力
			神兽转生潜能点加成 = 神兽转生潜能点加成 + qz(服务端参数.宝宝升级潜能点 / 5)
		end
	elseif self.数据[编号].种类 == "变异" then
		初始潜力 = 变异初始潜力
	elseif self.数据[编号].种类 == "宝宝" then
		初始潜力 = 宝宝初始潜力
	elseif self.数据[编号].种类 == "孩子" then
		初始潜力 = 孩子初始潜力
	elseif self.数据[编号].种类 == "野怪" then
		初始潜力 = 野怪初始潜力
	end

	初始潜力 = 初始潜力 + 转生加成

	if self.数据[编号].宠物图鉴属性 == nil then
		self.数据[编号].宠物图鉴属性 = {
			躲闪资质 = 0,
			体质 = 0,
			体力资质 = 0,
			速度 = 0,
			力量 = 0,
			防御 = 0,
			成长 = 0,
			灵力 = 0,
			速度资质 = 0,
			法力资质 = 0,
			魔力 = 0,
			最大魔法 = 0,
			敏捷 = 0,
			最大气血 = 0,
			耐力 = 0,
			伤害 = 0,
			攻击资质 = 0,
			防御资质 = 0
		}
	end

	self.数据[编号].体质 = self.数据[编号].等级 + 初始潜力
	self.数据[编号].魔力 = self.数据[编号].等级 + 初始潜力
	self.数据[编号].力量 = self.数据[编号].等级 + 初始潜力
	self.数据[编号].耐力 = self.数据[编号].等级 + 初始潜力
	self.数据[编号].敏捷 = self.数据[编号].等级 + 初始潜力
	self.数据[编号].潜力 = self.数据[编号].等级 * (服务端参数.宝宝升级潜能点 + 神兽转生潜能点加成) + self.数据[编号].灵性 * 2

	self:刷新信息(编号)

	return true
end

function 召唤兽处理类:保存加点方案(连接id, 序号, id, 内容)
	local 编号 = 内容.序列
	local 方案 = 内容.方案

	if self.数据[编号] ~= nil and not 判断是否为空表(方案) then
		self.数据[编号].加点方案 = {}
		local sx3 = {
			体质 = 1,
			力量 = 3,
			敏捷 = 5,
			耐力 = 4,
			魔力 = 2
		}

		for k, v in pairs(方案) do
			for i = 1, v do
				self.数据[编号].加点方案[#self.数据[编号].加点方案 + 1] = sx3[k]
			end
		end

		self.数据[编号].加点方案.当前 = 1
		self.数据[编号].加点文本 = 内容.文本
	end
end

function 召唤兽处理类:加点处理(连接id, 序号, id, 点数)
	local 临时编号 = self:取编号(点数.序列)
	local 监控开关 = false

	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	elseif 点数.力量 + 0 < 0 then
		封禁账号(id, "CE修改")

		return
	elseif 点数.耐力 + 0 < 0 then
		封禁账号(id, "CE修改")

		return
	elseif 点数.体质 + 0 < 0 then
		封禁账号(id, "CE修改")

		return
	elseif 点数.魔力 + 0 < 0 then
		封禁账号(id, "CE修改")

		return
	elseif 点数.敏捷 + 0 < 0 then
		封禁账号(id, "CE修改")

		return
	else
		local 总数点 = 0
		总数点 = 点数.力量 + 点数.体质 + 点数.耐力 + 点数.魔力 + 点数.敏捷

		if self.数据[临时编号].潜力 < 总数点 then
			常规提示(id, "该召唤兽没有那么多的可分配属性点")

			return
		end

		if 点数.力量 < 0 or 点数.魔力 < 0 or 点数.耐力 < 0 or 点数.体质 < 0 or 点数.敏捷 < 0 or self.数据[临时编号].潜力 < 点数.力量 or self.数据[临时编号].潜力 < 点数.魔力 or self.数据[临时编号].潜力 < 点数.耐力 or self.数据[临时编号].潜力 < 点数.体质 or self.数据[临时编号].潜力 < 点数.敏捷 then
			监控开关 = true
		end

		if 监控开关 then
			return 0
		end

		self.数据[临时编号].力量 = self.数据[临时编号].力量 + 点数.力量
		self.数据[临时编号].魔力 = self.数据[临时编号].魔力 + 点数.魔力
		self.数据[临时编号].耐力 = self.数据[临时编号].耐力 + 点数.耐力
		self.数据[临时编号].体质 = self.数据[临时编号].体质 + 点数.体质
		self.数据[临时编号].敏捷 = self.数据[临时编号].敏捷 + 点数.敏捷
		self.数据[临时编号].潜力 = self.数据[临时编号].潜力 - 总数点

		self:刷新信息(临时编号, "1")
		发送数据(连接id, 20, self:取存档数据(临时编号))

		if self.数据[临时编号].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
			玩家数据[id].角色.数据.参战宝宝 = {}
			玩家数据[id].角色.数据.参战宝宝 = table.loadstring(table.tostring(self:取存档数据(临时编号)))
			玩家数据[id].角色.数据.参战信息 = 1
			self.数据[临时编号].参战信息 = 1

			发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
		end
	end
end

function 召唤兽处理类:改名处理(连接id, 序号, id, 序列, 名称)
	local 临时编号 = self:取编号(序列)

	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	elseif 名称 == "" then
		常规提示(id, "名称不能为空")

		return
	elseif #名称 > 12 then
		常规提示(id, "名称太长了，换个试试！")

		return
	else
		self.数据[临时编号].名称 = 名称

		常规提示(id, "召唤兽名称修改成功！")
		发送数据(连接id, 19, {
			序列 = 临时编号,
			名称 = 名称
		})
	end
end

function 召唤兽处理类:参战处理(连接id, 序号, id, 序列)
	local 临时编号 = self:取编号(序列)
	local 高于等级 = 召唤兽参战高于等级

	if 玩家数据[id].角色.数据.剧情.飞升 == true and 玩家数据[id].角色.数据.飞升 == true then
		高于等级 = 召唤兽参战高于等级 + 飞升高于等级
	end

	if 临时编号 == 0 then
		常规提示(id, "你没有这只召唤兽")

		return
	elseif 玩家数据[id].角色.数据.等级 + 高于等级 < self.数据[临时编号].等级 then
		常规提示(id, "你目前的等级小于该召唤兽" .. 高于等级 .. "级以上,不允许参战")

		return
	elseif self.数据[临时编号].寿命 <= 50 then
		常规提示(id, "该召唤兽的寿命低于50无法参战")

		return
	else
		if 玩家数据[id].角色.数据.参战宝宝.认证码 == self.数据[临时编号].认证码 then
			玩家数据[id].角色.数据.参战宝宝 = {}
			self.数据[临时编号].参战信息 = nil
			玩家数据[id].角色.数据.参战信息 = nil

			if self.数据[临时编号].助战参战 ~= nil and 玩家数据[id].助战.数据[self.数据[临时编号].助战参战].宠物认证码 == nil then
				玩家数据[id].助战.数据[self.数据[临时编号].助战参战].宠物认证码 = self.数据[临时编号].认证码
			else
				self.数据[临时编号].助战参战 = nil
			end
		else
			for n = 1, #self.数据 do
				if self.数据[n].认证码 == 玩家数据[id].角色.数据.参战宝宝.认证码 then
					self.数据[n].参战信息 = nil
				end
			end

			if self.数据[临时编号].助战参战 ~= nil and 玩家数据[id].助战.数据[self.数据[临时编号].助战参战].宠物认证码 == self.数据[临时编号].认证码 then
				玩家数据[id].助战.数据[self.数据[临时编号].助战参战].宠物认证码 = nil
			end

			玩家数据[id].角色.数据.参战宝宝 = {}
			玩家数据[id].角色.数据.参战宝宝 = self.数据[临时编号]
			玩家数据[id].角色.数据.参战信息 = 1
			self.数据[临时编号].参战信息 = 1
		end

		发送数据(连接id, 18, 玩家数据[id].角色.数据.参战宝宝)
	end
end

function 召唤兽处理类:死亡处理(认证码, id)
	local 编号 = self:取编号(认证码)

	if self.数据[编号].种类 ~= "神兽" and self.数据[编号].种类 ~= "孩子" then
		self.数据[编号].寿命 = self.数据[编号].寿命 - 25

		if self.数据[编号].寿命 <= 0 then
			self.数据[编号].寿命 = 0
		end

		if 忠诚度开启 and 玩家数据[id].角色.数据.门派 ~= "狮驼岭" then
			self.数据[编号].忠诚 = math.max(self.数据[编号].忠诚 - 20, 0)
		end
	end

	if self.数据[编号].寿命 <= 50 then
		self.数据[编号].参战信息 = nil

		常规提示(玩家数据[self.数字id].连接id, "该召唤兽寿命过低，无法参加战斗")
	end
end

function 召唤兽处理类:刷新信息1(认证码, 参数)
	local 编号 = self:取编号(认证码)

	self:刷新信息(编号, 参数)

	if self.数据[编号] ~= nil and self.数据[编号].参战信息 ~= nil then
		玩家数据[self.数字id].角色.数据.参战宝宝 = self.数据[编号]

		发送数据(玩家数据[self.数字id].连接id, 18, 玩家数据[self.数字id].角色.数据.参战宝宝)
	end
end

function 召唤兽处理类:取编号(认证码)
	for n = 1, #self.数据 do
		if self.数据[n].认证码 == 认证码 then
			return n
		end
	end

	return 0
end

function 召唤兽处理类:飞升降级处理(id)
	for n = 1, #self.数据 do
		if self.数据[n].等级 >= 玩家数据[id].角色.数据.等级 + 10 then
			self.降低等级 = self.数据[n].等级 - 10 - 玩家数据[id].角色.数据.等级

			self:降级(self.降低等级, n)
		end
	end
end

function 召唤兽处理类:更新(dt)
end

function 召唤兽处理类:显示(x, y)
end

function 召唤兽处理类:打书概率(v, 一键顶书)
	local g = ygsj(10000)
	local aa = {}

	if 一键顶书 ~= nil then
		g = qz(g / 一键顶书概率比例)
	end

	if v < 打书必上技能数 - 1 then
		return true
	elseif v <= 打书最大格子数 - 1 and g <= 打书概率列表[v] then
		return true
	end

	return false
end

function 召唤兽处理类:取经验(id, lv)
	local exp = {}

	if id == 1 then
		exp = {
			40,
			110,
			237,
			450,
			779,
			1252,
			1898,
			2745,
			3822,
			5159,
			6784,
			8726,
			11013,
			13674,
			16739,
			20236,
			24194,
			28641,
			33606,
			39119,
			45208,
			51902,
			55229,
			67218,
			75899,
			85300,
			95450,
			106377,
			118110,
			130679,
			144112,
			158438,
			173685,
			189882,
			207059,
			225244,
			244466,
			264753,
			286134,
			308639,
			332296,
			357134,
			383181,
			410466,
			439019,
			468868,
			500042,
			532569,
			566478,
			601799,
			638560,
			676790,
			716517,
			757770,
			800579,
			844972,
			890978,
			938625,
			987942,
			1038959,
			1091704,
			1146206,
			1202493,
			1260594,
			1320539,
			1382356,
			1446074,
			1511721,
			1579326,
			1648919,
			1720528,
			1794182,
			1869909,
			1947738,
			2027699,
			2109820,
			2194130,
			2280657,
			2369431,
			2460479,
			2553832,
			2649518,
			2747565,
			2848003,
			2950859,
			3056164,
			3163946,
			3274233,
			3387055,
			3502439,
			3620416,
			3741014,
			3864261,
			3990187,
			4118819,
			4250188,
			4384322,
			4521249,
			4660999,
			4803599,
			4998571,
			5199419,
			5406260,
			5619213,
			5838397,
			6063933,
			6295941,
			6534544,
			6779867,
			7032035,
			7291172,
			7557407,
			7830869,
			8111686,
			8399990,
			8695912,
			8999586,
			9311145,
			9630726,
			9958463,
			10294496,
			10638964,
			10992005,
			11353761,
			11724374,
			12103988,
			12492748,
			12890799,
			13298287,
			13715362,
			14142172,
			14578867,
			15025600,
			15482522,
			15949788,
			16427552,
			16915970,
			17415202,
			17925402,
			18446732,
			18979354,
			19523428,
			20079116,
			20646584,
			21225998,
			43635044,
			44842648,
			46075148,
			47332886,
			48616200,
			74888148,
			76891401,
			78934581,
			81018219,
			83142835,
			85308969,
			87977421,
			89767944,
			92061870,
			146148764,
			150094780,
			154147340,
			158309318,
			162583669,
			166973428,
			171481711,
			176111717,
			180866734,
			185780135,
			240602904,
			533679362,
			819407100,
			1118169947,
			1430306664,
			1756161225,
			2096082853
		}
	else
		exp = {
			50,
			200,
			450,
			800,
			1250,
			1800,
			2450,
			3250,
			4050,
			5000,
			6050,
			7200,
			8450,
			9800,
			11250,
			12800,
			14450,
			16200,
			18050,
			20000,
			22050,
			24200,
			26450,
			28800,
			31250,
			33800,
			36450,
			39200,
			42050,
			45000,
			48050,
			51200,
			54450,
			57800,
			61250,
			64800,
			68450,
			72200,
			76050,
			400000,
			420250,
			441000,
			462250,
			484000,
			506250,
			529000,
			552250,
			576000,
			600250,
			625000,
			1300500,
			1352000,
			1404500,
			1458000,
			1512500,
			1568000,
			1624500,
			1682000,
			1740500,
			1800000,
			1860500,
			1922000,
			1984500,
			2048000,
			2112500,
			2178000,
			2244500,
			2312000,
			2380500,
			2450000,
			2520500,
			2592000,
			2664500,
			2738000,
			2812500,
			2888000,
			2964500,
			3042000,
			3120500,
			3200000,
			3280500,
			3362000,
			3444500,
			3528000,
			3612500,
			3698000,
			3784500,
			3872000,
			3960500,
			4050000,
			4140500,
			4232000,
			4324500,
			4418000,
			4512500,
			4608000,
			4704500,
			4802000,
			4900500,
			5000000,
			5100500,
			5202000,
			5304500,
			5408000,
			5512500,
			5618000,
			5724500,
			5832000,
			5940500,
			6050000,
			6160500,
			6272000,
			6384500,
			6498000,
			6612500,
			6728000,
			6844500,
			6962000,
			7080500,
			7200000,
			7320500,
			7442000,
			7564500,
			7688000,
			7812500,
			7938000,
			8064500,
			8192000,
			8320500,
			8450000,
			8580500,
			8712000,
			8844500,
			8978000,
			9112500,
			9248000,
			9384500,
			9522000,
			9660500,
			9800000,
			9940500,
			10082000,
			10224500,
			10368000,
			10512500,
			10658000,
			10804500,
			10952000,
			11100500,
			11250000,
			11400500,
			11552000,
			11704500,
			11858000,
			12012500,
			12168000,
			12324500,
			12482000,
			12640500,
			12800000,
			13000000,
			13400000,
			13800000,
			14200000,
			14600000,
			15000000,
			15400000,
			15800000,
			17000000,
			17800000,
			18200000,
			19400000,
			24000000,
			28800000,
			32200000,
			40200000,
			42200000,
			44200000,
			46200000,
			52200000,
			58200000,
			62200000,
			70200000,
			80200000,
			90200000
		}
	end

	return exp[lv + 1] or 10000000000.0
end

return 召唤兽处理类
